# quokkapix/quokkapix-mcp [Health: Active]

**Category:** 🎨 Art & Culture  
**Repository:** https://github.com/quokkapix/quokkapix-mcp  
**GitHub Stars:** 1  
**npm Downloads (last month):** 143  
**Views:** 4  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/quokkapix-quokkapix-mcp

## Description
Local MCP adapter/server for browser-only image workflows. Resize, compress, convert, remove backgrounds, strip metadata, watermark and export image packs through QuokkaPix without uploading source images to a processing server. npx quokkapix-mcp

## Tools
Capabilities this server exposes over MCP:

- **list_recipes** — List official QuokkaPix local/browser image workflow recipes. Use this first when an agent needs a supported workflow for Shopify, Amazon, Google Merchant, WebP compression, metadata cleanup, social packs, watermarking, favicon generation or similar repeatable image tasks. Returns ids that can be passed to get_recipe or process_images.
- **get_recipe** — Return one official QuokkaPix recipe by id. Use this before process_images when the agent needs exact applySettings, max file limits, payment expectations and expected result QA checks. This tool does not process images.
- **validate_recipe** — Validate a custom QuokkaPix recipe before using process_images. Use this when an agent generated its own recipe JSON and needs to confirm that id, applySettings.mode, applySettings.tool, optional structured steps and requires.maxFiles are valid. This is a preflight check only and does not open a browser or process files.
- **list_rule_profiles** — List sourced image requirement profiles for marketplaces and social placements. Use this before marketplace QA when an agent needs facts for Amazon, Shopify, Google Merchant, Etsy, eBay, Walmart, TikTok Shop, Mercado Libre, Temu, Shopee, Instagram, YouTube, LinkedIn, X, Pinterest, Facebook or TikTok. Secondary sources are marked explicitly.
- **get_rule_profile** — Return one sourced platform image rule profile by id, including requirements, recommendations, source URL, source type and confidence. This tool does not process files and does not invent missing marketplace rules.
- **validate_result_manifest** — Validate an existing quokkapix-result.json manifest against an official recipe or custom QA contract. Use this after process_images/process_with_settings or when inspecting a previous run. It checks status, file counts, formats, dimensions, size limits, ZIP entry metadata and marketplace QA metadata; it does not read image pixels or upload files.
- **process_images** — Process local image files through the QuokkaPix browser app using an official recipeId or a full custom recipe. Source files stay local. Without unlockToken, the browser returns an exact quote after ZIP expansion/PDF inspection and before paid processing. Retry the unchanged call with the quoted product token.
- **process_with_settings** — Process local image files with a direct window.QuokkaPixAgent.applySettings payload instead of an official recipe. Use this for custom resize/crop/convert/compress/background/watermark/effects/rename/PDF/favicon/scenario workflows. For multi-step scenarios, prefer settings.steps as [{ tool, settings }]. The adapter downloads the output, writes quokkapix-result.json and returns QA results.
- **list_video_recipes** — List official browser-local recipes for cutting, crop/resize, conversion, compression, audio, transcription and subtitles.
- **get_video_recipe** — Return one official Video recipe, its browser settings and expected-result QA.
- **validate_video_recipe** — Validate a custom Video recipe without opening a browser or processing media.
- **list_video_rule_profiles** — List official-source profiles for YouTube, TikTok Ads and Meta Reels video workflows.
- **get_video_rule_profile** — Return one Video profile with separate requirements, recommendations and source URL.
- **validate_video_result_manifest** — Validate quokkapix-video-result.json against its browser QA and an optional Video recipe.
- **process_video** — Open Video in local Chromium and keep media local. Without unlockToken, return an exact duration/transcription quote before paid work; retry the same call with the product-specific token.
- **process_video_with_settings** — Run one local video through window.QuokkaPixVideoAgent.applySettings-compatible settings, save the media or transcript output and write quokkapix-video-result.json.
- **get_payment_options** — Fetch live QuokkaPix Image and Video payment tiers, free limits and product-specific x402 endpoints. This tool does not sign, submit or consume a payment.
- **explain_payment_flow** — Explain the unified Image/PDF/Video x402 workflow: inspect locally, quote exactly, pay the product endpoint, optionally verify, then retry unchanged with unlockToken. This adapter can use a token but cannot sign x402 payments itself.
- **verify_unlock_token** — Safely preflight a QuokkaPix paid agent unlock token without consuming it. The browser consumes the one-time unlock only when the paid batch actually starts. If scope, price or currency are omitted, the tool reads live payment options first.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "quokkapix-mcp": {
    "command": "npx",
    "args": ["-y","quokkapix-mcp"]
  }
}
```

## Documentation

## What quokkapix/quokkapix-mcp MCP server does

The quokkapix/quokkapix-mcp MCP server provides an MCP interface for local QuokkaPix Image and Video browser workflows. It opens the relevant QuokkaPix surface in local Chromium, selects files through the browser input, applies an official recipe or supplied settings, downloads the result, and writes a result manifest. Image jobs produce `quokkapix-result.json`; video jobs produce `quokkapix-video-result.json`.

Supported work includes image resizing, cropping, conversion, compression, background removal, metadata stripping, watermarking, renaming, PDF and favicon workflows, and export packs. Video workflows cover cutting, cropping, resizing, conversion, compression, audio operations, local transcription, and subtitle output. The supplied tools also expose sourced image and video requirement profiles for marketplace, social, YouTube, TikTok Ads, and Meta Reels use cases.

## How it works

The adapter uses Playwright to control local Chromium and calls `window.QuokkaPixAgent` for images or `window.QuokkaPixVideoAgent` for video. Processing happens in the browser runtime. The package does not provide a server-side media-processing API, and local file paths are available only to the local runner.

In stdio mode, an MCP client communicates directly with the local process. Bridge mode adds a remote control path: a remote MCP client sends commands, relative file names, status, and result metadata through the QuokkaPix control plane, while the paired bridge performs the work on the user's computer. The bridge does not relay source or output media bytes and restricts access to its configured input and output roots.

## Setup and configuration

The quokkapix/quokkapix-mcp MCP server requires Node.js 20 or newer, npm, Playwright Chromium, internet access for QuokkaPix and browser-side dependencies when needed, and readable local file paths. Install dependencies with `npm install` and install Chromium with `npx playwright install chromium`. A basic launch is:

```bash
npx quokkapix-mcp
```

For remote clients, start bridge mode with explicit directories:

```bash
npx -y quokkapix-mcp bridge --input-root /absolute/path/to/input --output-root /absolute/path/to/output
```

Approve the printed pairing URL, add `https://quokkapix.com/mcp` as a remote MCP connector, and complete OAuth authorization. `--pair` authorizes another browser session; `--reset` revokes the previous device authorization and creates a new credential. Bridge credentials are stored in `~/.quokkapix/bridge.json`.

## Tools and capabilities

Recipe and validation tools support a staged workflow:

- `list_recipes` and `list_video_recipes` show official image and video workflows.
- `get_recipe` and `get_video_recipe` return settings, limits, expected results, and payment information.
- `validate_recipe` and `validate_video_recipe` check custom definitions before processing.
- `list_rule_profiles`, `get_rule_profile`, `list_video_rule_profiles`, and `get_video_rule_profile` expose sourced requirements and recommendations.
- `validate_result_manifest` and `validate_video_result_manifest` inspect existing QA manifests without reading image pixels or uploading files.

`process_images` and `process_video` run official or custom workflows. They can return an exact payment quote before paid processing when no unlock token is supplied. `process_with_settings` and `process_video_with_settings` apply direct agent-compatible settings. Payment-related tools fetch options, explain the x402 sequence, and preflight an unlock token; they do not sign or submit payments.

## Limitations and notes

Browser memory limits still apply. This package is not a hosted processing service, GPU or CPU backend, or a mechanism for passing local paths to QuokkaPix by URL. Internet access may be needed for browser dependencies and locally used transcription models. Local transcription can download and cache Whisper model files, but the selected media is not uploaded with that model request.

Marketplace profiles identify their source type, URL, and confidence, and may be secondary or category- or country-specific where public official specifications are limited. Manifest validation checks reported metadata and supported QA fields; it does not inspect image pixels unless pixel QA data is already present in the browser result manifest.

_Full upstream README: https://allmcps.com/mcp/quokkapix-quokkapix-mcp/readme_