# io.github.pictify-io/mcp (remote · mcp.pictify.io)

Generate images, GIFs, and PDFs from HTML, URLs, or templates — from your AI agent.

- Trust score: 65/100 (medium)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `mcp.pictify.io`: 65/100 (this document), [markdown](https://verifymcp.io/servers/pictify-io-mcp/mcp.md), [page](https://verifymcp.io/servers/pictify-io-mcp/mcp)
- npm · `@pictify/mcp-server`: 35/100, [markdown](https://verifymcp.io/servers/pictify-io-mcp/pictify-mcp-server.md), [page](https://verifymcp.io/servers/pictify-io-mcp/pictify-mcp-server)

## Channel facts

- Endpoint: `https://mcp.pictify.io`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.3.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Endpoint Security**: 57/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 31 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 68/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 5772 tokens (~186/item across 31 items; 31 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http pictify-io-mcp https://mcp.pictify.io/
```

### Codex

```toml
[mcp_servers.pictify-io-mcp]
url = "https://mcp.pictify.io/"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "pictify-io-mcp": {
      "type": "remote",
      "url": "https://mcp.pictify.io/",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add pictify-io-mcp --url https://mcp.pictify.io/ --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  pictify-io-mcp:
    url: "https://mcp.pictify.io/"
```

### Other

```json
{
  "mcpServers": {
    "pictify-io-mcp": {
      "type": "http",
      "url": "https://mcp.pictify.io/"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 65, 0)

- [functional] Server version: 1.3.0 → 1.4.0

### 2026-08-02 (score 65, +1)

No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-31 (score 64, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 64, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-28 (score 63, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-27 (score 62, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 61)

First indexed and scored.

## MCP tools (31)

### `pictify_create_image` (~575 tokens)

Generate a static image (PNG, JPEG, or WebP) from HTML/CSS content, a URL screenshot, or a template. Common use cases: Open Graph (OG) images for link previews, social media cards (Twitter/LinkedIn/Facebook), product screenshots, marketing banners, event invitations, and custom graphics. Provide ONE of: 'html' (custom HTML/CSS), 'url' (screenshot a webpage), or 'template' + 'variables' (render a saved template). Returns the hosted image URL (CDN-backed) and asset ID. Maximum dimensions: 4000x4000 pixels. IMPORTANT: The renderer captures the element's actual rendered size, not the viewport. If your HTML content is shorter than the requested height, the output image will be clipped to the content height. To ensure exact dimensions, set explicit width and height on your root element (e.g., a wrapper div) using CSS like: position: absolute; top: 0; left: 0; width: 1920px; height: 1080px; — this guarantees the element fills the full requested area.

Input parameters:

- `fileExtension` (string): Output image format. PNG for transparency support, JPEG/JPG for photos (smaller file size), WebP for best compression.
- `height` (number): Image height in pixels (1-4000)
- `html` (string): HTML content to render as an image. Include inline CSS or <style> tags for styling. Google Fonts supported via <link> tags. Mutually exclusive with 'url' and 'template'. IMPORTANT: To get exact outpu…
- `selector` (string): CSS selector to capture a specific element instead of the full page (e.g., '.card', '#hero'). Useful when your HTML contains multiple elements but you only want to capture one.
- `template` (string): Template UID to render. Use with 'variables' to substitute dynamic values. Mutually exclusive with 'html' and 'url'. Use pictify_list_templates to find templates.
- `url` (string): URL of a web page to screenshot. Must be publicly accessible http:// or https://. Mutually exclusive with 'html' and 'template'.
- `variables` (object): Template variables as key-value pairs. Only used when 'template' is provided.
- `width` (number): Image width in pixels (1-4000). Common sizes: 1200x630 (OG image), 1080x1080 (Instagram), 1200x675 (Twitter card), 1920x1080 (presentation slide)

### `pictify_create_canvas_image` (~227 tokens)

Generate an image from FabricJS canvas JSON data with optional variable substitution. Use this when you have a FabricJS canvas design (created in the Pictify visual editor or programmatically). Templates in Pictify are built using FabricJS — this endpoint lets you render canvas JSON directly without saving it as a template first. For rendering a saved template, use pictify_render_template instead. Returns the hosted image URL (CDN-backed).

Input parameters:

- `fabricJSData` (object, required): FabricJS canvas JSON object. This is the serialized canvas data from FabricJS (canvas.toJSON()). Contains objects array with shapes, text, images, and their properties.
- `fileExtension` (string): Output image format
- `height` (number): Output image height in pixels. If omitted, uses the canvas height.
- `variableDefinitions` (array): Variable definitions describing the types and defaults for each variable.
- `variables` (object): Variables to substitute into the canvas elements that have variable bindings.
- `width` (number): Output image width in pixels. If omitted, uses the canvas width.

### `pictify_list_images` (~78 tokens)

List previously generated images from your account with pagination. Returns image URLs, IDs, dimensions, format, and creation timestamps. Use this to browse your render history or find a previously generated image.

Input parameters:

- `limit` (number): Number of images to return (1-100)
- `offset` (number): Number of images to skip for pagination

### `pictify_get_image` (~46 tokens)

Get details of a specific image by its UID. Returns the image URL, dimensions, format, and creation timestamp.

Input parameters:

- `imageId` (string, required): The image UID to retrieve

### `pictify_create_gif` (~312 tokens)

Create an animated GIF from HTML content with CSS animations, a URL, or a template. The HTML must contain CSS @keyframes animations, transitions, or JavaScript animations to produce frames. Common use cases: animated banners, loading spinners, product demos, social media animations, animated logos, and eye-catching ad creatives. Provide ONE of: 'html' (custom animated HTML/CSS), 'url' (capture from webpage), or 'template' + 'variables' (render a saved template). For recording a GIF from a live website over a specified duration, use pictify_capture_gif instead. Returns the hosted GIF URL and animation duration. Maximum dimensions: 2000x2000 pixels.

Input parameters:

- `height` (number): GIF height in pixels (1-2000)
- `html` (string): HTML content with CSS animations to render as an animated GIF. Must include CSS @keyframes or transitions for animation. Mutually exclusive with 'url' and 'template'.
- `template` (string): Template UID to render as a GIF. Use with 'variables'. Mutually exclusive with 'html' and 'url'.
- `url` (string): URL of a web page to capture as a GIF. Mutually exclusive with 'html' and 'template'.
- `variables` (object): Template variables as key-value pairs. Only used when 'template' is provided.
- `width` (number): GIF width in pixels (1-2000). Keep dimensions reasonable for file size.

### `pictify_capture_gif` (~269 tokens)

Record an animated GIF from a live web page URL by capturing its on-screen activity over time. The page is loaded in a headless browser and recorded for the specified duration. Use cases: capturing CSS/JS animations on live sites, recording interactive demos, documenting UI transitions, creating product walkthroughs. This operation takes time proportional to the duration setting (up to 30 seconds). For creating GIFs from custom HTML with CSS animations, use pictify_create_gif instead. Returns the hosted GIF URL.

Input parameters:

- `frameDurationSeconds` (number): Recording duration in seconds (1-30). The page is captured for this many seconds. Longer durations produce larger GIF files and take longer to process.
- `height` (number): Capture viewport height in pixels (1-2000)
- `quality` (string): GIF quality preset. 'low' (10fps, up to 10s), 'medium' (15fps, up to 15s), 'high' (24fps, up to 30s). Higher quality = larger file size.
- `url` (string, required): URL of the web page to capture as a GIF. Must be a publicly accessible http:// or https:// URL.
- `width` (number): Capture viewport width in pixels (1-2000)

### `pictify_list_gifs` (~83 tokens)

List previously generated GIFs from your account with pagination. Returns GIF URLs, IDs, dimensions, animation duration, and creation timestamps. Use this to browse your GIF history or find a previously generated animation.

Input parameters:

- `limit` (number): Number of GIFs to return (1-100)
- `offset` (number): Number of GIFs to skip for pagination

### `pictify_get_gif` (~49 tokens)

Get details of a specific GIF by its UID. No authentication required. Returns the GIF URL, dimensions, and animation details.

Input parameters:

- `gifId` (string, required): The GIF UID to retrieve

### `pictify_render_pdf` (~270 tokens)

Generate a single-page PDF from a saved template with variable substitutions. Common use cases: invoices, certificates, receipts, contracts, reports, event tickets, shipping labels, and any document that needs to be generated programmatically. WORKFLOW: Call pictify_get_template_variables first to discover available variables and their types, then call this tool with the appropriate variable values. Supports standard page sizes (A4, Letter, Legal, etc.) — use pictify_list_pdf_presets to see all options. Returns the hosted PDF URL.

Input parameters:

- `preset` (string): PDF page size preset (e.g., 'A4', 'Letter', 'Legal'). Use pictify_list_pdf_presets to see all available presets with their dimensions. If not specified, uses the template's default dimensions.
- `templateId` (string, required): The template UID to render as a PDF. Use pictify_list_templates to find available templates.
- `title` (string): PDF document title metadata — appears in the browser tab when the PDF is opened
- `variables` (object): Template variables as key-value pairs (e.g., { title: 'Invoice #001', amount: '$1,000', date: '2024-03-09' }). Use pictify_get_template_variables to discover available variable names and types.

### `pictify_render_multi_page_pdf` (~238 tokens)

Generate a multi-page PDF from a template by providing multiple sets of variables. Each variable set produces one page in the final document. Supports 1-100 pages per PDF. Common use cases: bulk invoice generation, certificate batches for events/courses, multi-page reports, product catalogs, and employee ID cards. WORKFLOW: Call pictify_get_template_variables first to discover available variables, then provide an array of variable sets (one per page). Returns a single combined PDF URL. For generating separate image files per set, use pictify_batch_render instead.

Input parameters:

- `preset` (string): PDF page size preset (e.g., 'A4', 'Letter'). Use pictify_list_pdf_presets to see options.
- `templateId` (string, required): The template UID to render as a multi-page PDF
- `title` (string): PDF document title metadata
- `variableSets` (array, required): Array of variable sets, one per page (1-100 items). Example: [{ name: 'Alice', score: '95' }, { name: 'Bob', score: '87' }] produces a 2-page PDF.

### `pictify_list_pdf_presets` (~73 tokens)

List all available PDF page size presets with their dimensions. Use these preset names when calling pictify_render_pdf or pictify_render_multi_page_pdf. Common presets include A4 (210x297mm), Letter (8.5x11in), Legal (8.5x14in), and more.

### `pictify_list_templates` (~133 tokens)

List saved templates in your Pictify account with pagination and filtering. Templates are reusable designs (built with the FabricJS visual editor or HTML) with variable placeholders for dynamic content generation. Use this to discover available templates before rendering. Returns template names, IDs, dimensions, output formats, and pagination info.

Input parameters:

- `limit` (number): Number of templates per page (1-100, default 12)
- `outputFormat` (string): Filter templates by their output format type
- `page` (number): Page number for pagination (starts at 1)
- `sort` (string): Sort order for results

### `pictify_get_template` (~65 tokens)

Get detailed information about a specific template by its ID. Returns the template's name, dimensions, variable definitions, tags, output format, thumbnail URL, and metadata. Use this to inspect a template before rendering.

Input parameters:

- `templateId` (string, required): The template UID to retrieve

### `pictify_get_template_variables` (~127 tokens)

Get the variable definitions for a template. IMPORTANT: Always call this before pictify_render_template, pictify_batch_render, pictify_render_pdf, or pictify_render_multi_page_pdf to discover what variables are available. Returns variable names, types (text, image, color, number, boolean), default values, and descriptions. Variables support Pictify's expression engine with 50+ functions for dynamic content (e.g., IF/ELSE conditionals, string manipulation, date formatting, math operations).

Input parameters:

- `templateId` (string, required): The template UID to get variables for

### `pictify_render_template` (~344 tokens)

Render a saved template with variable substitutions to produce an image or PDF. Templates can be FabricJS canvas designs or HTML — both are rendered the same way via this endpoint. WORKFLOW: 1) Use pictify_list_templates to find a template, 2) Use pictify_get_template_variables to discover its variables, 3) Call this tool with the variable values. Common use cases: OG images with dynamic titles, personalized social cards, product images with prices/descriptions, event banners with speaker info. For rendering the same template with many variable sets, use pictify_batch_render. Returns the hosted image URL (CDN-backed).

Input parameters:

- `format` (string): Output format. PNG for transparency, JPEG for photos, WebP for web optimization, PDF for documents.
- `layout` (string): Render a specific layout variant (e.g., 'twitter-post', 'facebook-post'). Omit for default layout. Use pictify_get_template to see available layouts.
- `layouts` (array): Render multiple layout variants in one request. Use 'default' for the base layout. Example: ['default', 'twitter-post', 'facebook-post']. Returns a results array with one entry per layout.
- `quality` (number): Output quality (0.1-1.0). Lower values reduce file size. Only affects JPEG and WebP.
- `templateId` (string, required): The template UID to render
- `variables` (object): Template variables as key-value pairs. Example: { title: 'My Blog Post', author: 'Jane Doe', avatar_url: 'https://...' }. Use pictify_get_template_variables to see available variables and their types.

### `pictify_create_template` (~436 tokens)

Create a new reusable template with variable placeholders for dynamic content generation. Templates can use either FabricJS canvas data (from the Pictify visual editor) or raw HTML. Provide ONE of 'html' or 'fabricJSData' — they are mutually exclusive. For HTML templates, use {{variableName}} syntax for dynamic placeholders. Pictify's expression engine supports 50+ functions: IF/ELSE conditionals, string manipulation (toUpperCase, truncate, etc.), date formatting, math operations, and more. After creating, use pictify_render_template to render it with specific values. Returns the created template's ID.

Input parameters:

- `category` (string): Template category for organization
- `fabricJSData` (object): FabricJS canvas JSON object (from canvas.toJSON()). Mutually exclusive with 'html'. This is the standard format from Pictify's visual editor. Canvas objects can have variable bindings for dynamic con…
- `height` (number): Template height in pixels (1-4000)
- `html` (string): HTML content for the template. Use {{variableName}} for dynamic placeholders. Mutually exclusive with 'fabricJSData'. Supports expressions: '{{IF(premium, "PRO", "FREE")}}', '{{price * 1.1}}'. Includ…
- `name` (string, required): Template name for identification and organization
- `outputFormat` (string): Default output format: 'image' for PNG/JPEG/WebP, 'pdf' for PDF documents
- `tags` (array): Tags for organizing and filtering templates (e.g., ['social', 'marketing', 'og-image'])
- `type` (string): Template type (e.g., 'banner', 'card', 'certificate')
- `variableDefinitions` (array): Explicit variable definitions with types and defaults
- `width` (number): Template width in pixels (1-4000). Common: 1200x630 (OG), 1080x1080 (social square), 1920x1080 (presentation)

### `pictify_update_template` (~171 tokens)

Update an existing template's content, dimensions, name, or variable definitions. Only the provided fields will be updated; others remain unchanged. You can update HTML or FabricJS data — provide one or the other, not both. Note: updating content may change the available variables.

Input parameters:

- `fabricJSData` (object): New FabricJS canvas JSON. Mutually exclusive with 'html'.
- `height` (number): New height in pixels (1-4000)
- `html` (string): New HTML content. Mutually exclusive with 'fabricJSData'.
- `name` (string): New template name
- `templateId` (string, required): The template UID to update
- `variableDefinitions` (array): Updated variable definitions
- `width` (number): New width in pixels (1-4000)

### `pictify_delete_template` (~52 tokens)

Permanently delete a template. This action cannot be undone. WARNING: Any batch jobs, experiments, or bindings using this template will stop working.

Input parameters:

- `templateId` (string, required): The template UID to delete

### `pictify_batch_render` (~396 tokens)

Start a batch render job to generate multiple images from a single template with different variable sets. Each variable set produces a separate image. Supports up to 100 items per batch (plan-dependent). Common use cases: generating personalized social cards for all team members, product images for an entire catalog, event badges for all attendees, certificate images for course graduates, or marketing assets with localized content. WORKFLOW: 1) Use pictify_get_template_variables to discover variables, 2) Call this tool with an array of variable sets, 3) Use pictify_get_batch_results to poll for completion and get result URLs. The job runs asynchronously — this tool returns immediately with a batchId (HTTP 202). For generating a single multi-page PDF instead, use pictify_render_multi_page_pdf.

Input parameters:

- `concurrency` (number): Number of concurrent renders (1-10). Higher values complete faster but consume quota faster. Plan limits: Free=1, Pro=3, Business=10.
- `format` (string): Output format for all rendered images
- `layout` (string): Render all batch items using a specific layout variant (e.g., 'twitter-post'). Omit for default layout.
- `layouts` (array): Render all batch items across multiple layout variants. Use 'default' for the base layout. Example: ['default', 'twitter-post']. Each batch item will produce one image per layout (2D results).
- `quality` (number): Output quality (0.1-1.0) for all rendered images. Only affects JPEG and WebP.
- `templateId` (string, required): The template UID to batch render
- `variableSets` (array, required): Array of variable sets (1-100 items). Each item produces a separate image. Example: [{ name: 'Alice', role: 'CEO' }, { name: 'Bob', role: 'CTO' }] generates 2 images.

### `pictify_get_batch_results` (~114 tokens)

Check the status and results of a batch render job. Returns the job status (pending, processing, completed, failed, partial, cancelled), progress percentage, item counts, and image URLs for completed items. Each result includes index, success boolean, URL, dimensions, and error message (if failed). Call this after pictify_batch_render. If status is 'processing', call again after a few seconds to check for updates.

Input parameters:

- `batchId` (string, required): The batch job ID returned by pictify_batch_render

### `pictify_cancel_batch` (~67 tokens)

Cancel a running batch render job. Already completed items will retain their results and URLs. Remaining unprocessed items will be skipped. Use this if you started a batch with incorrect data or no longer need the remaining results.

Input parameters:

- `batchId` (string, required): The batch job ID to cancel

### `pictify_list_experiments` (~209 tokens)

List A/B test experiments with optional filtering by type and status. Pictify experiments let you test different image variants to optimize for engagement. Types: 'ab_test' (split traffic between variants with Thompson Sampling auto-optimization), 'smart_link' (rules-based personalization by device/geo/time/browser/referrer), 'scheduled' (time-based image swapping with cron/daily/weekly recurrence). Returns experiment names, IDs, types, statuses, variant details, and pagination info.

Input parameters:

- `limit` (number): Number of results per page (1-100)
- `page` (number): Page number for pagination
- `status` (string): Filter by experiment status
- `type` (string): Filter by experiment type. 'ab_test': split traffic between image variants with auto-optimization. 'smart_link': serve different images based on rules (device, location, time, browser, referrer). 'sc…

### `pictify_create_experiment` (~592 tokens)

Create a new experiment to test different image variants. WORKFLOW: 1) Create the experiment (starts in 'draft' status), 2) Use pictify_start_experiment to begin routing traffic, 3) Use pictify_get_experiment to monitor variant impressions/clicks, 4) Use pictify_complete_experiment to declare a winner. Requires at least 2 variants. Variant weights must sum to exactly 10000 (basis points, i.e., 5000 = 50%). The slug becomes part of the experiment URL and must be unique, 3-60 chars, lowercase alphanumeric and hyphens. For A/B tests, enable banditConfig to use Thompson Sampling auto-optimization.

Input parameters:

- `banditConfig` (object): Auto-optimization settings. Only applies to ab_test type. Uses Thompson Sampling to shift traffic toward the winning variant.
- `confidenceThreshold` (number): Required confidence level (0-1) to declare a winner (default 0.95 = 95%)
- `fallbackImageUrl` (string): Fallback image URL to serve if the experiment or variant fails to render
- `goalConfig` (object): Goal configuration. Determines what counts as a conversion.
- `hypothesis` (string): Hypothesis being tested (e.g., 'A green CTA button will increase click-through rate by 15%'). Optional but recommended for tracking experiment goals.
- `minimumRunDays` (number): Minimum days the experiment must run before completion
- `minimumSampleSize` (number): Minimum impressions before results are considered statistically significant
- `name` (string, required): Human-readable experiment name (e.g., 'Homepage CTA Button Test')
- `outputConfig` (object): Output image format and quality for rendered variants
- `slug` (string, required): Unique URL-safe identifier for this experiment (3-60 chars, lowercase alphanumeric + hyphens). Used in tracking URLs: /s/{slug}/pixel.gif, /s/{slug}/click. Cannot be reserved words: events, api, admi…
- `templateUid` (string): Default template UID for all variants. Individual variants can override this.
- `type` (string, required): Experiment type. 'ab_test': randomly split traffic between variants (supports auto-optimization). 'smart_link': serve variants based on condition rules (device, country, time, custom properties). 'sc…
- `variants` (array, required): At least 2 variants required. Weights must sum to 10000. Example: [{ id: 'control', name: 'Original', weight: 5000, templateUid: 'tmpl_123' }, { id: 'variant-a', name: 'New Design', weight: 5000, tem…

### `pictify_get_experiment` (~90 tokens)

Get detailed information about a specific experiment. Returns the experiment's name, type, status, slug, variants with their configurations, traffic weights, impression/click counts per variant, hypothesis, goal and bandit configuration, confidence threshold, minimum run days, and timestamps. Use this to monitor experiment performance and review setup before making changes.

Input parameters:

- `experimentId` (string, required): The experiment UID to retrieve

### `pictify_get_experiment_quota` (~65 tokens)

Check experiment usage and limits for your current plan. Returns quota usage for each experiment type (ab_test, smart_link, scheduled), maximum variants allowed per experiment, and analytics retention period in days. Use this before creating experiments to check if you have quota remaining.

### `pictify_update_experiment` (~244 tokens)

Update an existing experiment. Available fields depend on the current status:
\- draft/paused: All fields can be updated (name, slug, variants, goalConfig, banditConfig, hypothesis, etc.)
\- running: Only name, confidenceThreshold, minimumRunDays, goalConfig.destinationUrl
\- completed: Only name

If updating variants, weights must still sum to 10000.

Input parameters:

- `banditConfig` (object): Updated auto-optimization settings
- `confidenceThreshold` (number): Updated confidence threshold (editable when running)
- `experimentId` (string, required): The experiment UID to update
- `fallbackImageUrl` (string): Updated fallback image URL
- `goalConfig` (object): Updated goal configuration
- `hypothesis` (string): Updated hypothesis
- `minimumRunDays` (number): Updated minimum run days (editable when running)
- `name` (string): New experiment name
- `outputConfig` (object): Updated output format/quality
- `slug` (string): New slug (only when draft/paused)
- `variants` (array): Updated variants. Weights must sum to 10000. Only editable when draft/paused.

### `pictify_delete_experiment` (~45 tokens)

Soft-delete an experiment. This cannot be undone. Running experiments must be paused or completed first before deletion.

Input parameters:

- `experimentId` (string, required): The experiment UID to delete

### `pictify_start_experiment` (~85 tokens)

Start a draft or paused experiment, activating traffic routing to its variants. Once started, the experiment serves different image variants and tracks events. Valid transitions: draft -> running, paused -> running. If banditConfig is enabled (A/B tests), Thompson Sampling auto-optimizes traffic toward the winning variant.

Input parameters:

- `experimentId` (string, required): The experiment UID to start

### `pictify_pause_experiment` (~63 tokens)

Pause a running experiment, temporarily stopping traffic routing and event tracking. Valid transition: running -> paused. The experiment can be resumed later with pictify_start_experiment. Collected data is preserved.

Input parameters:

- `experimentId` (string, required): The experiment UID to pause

### `pictify_complete_experiment` (~136 tokens)

Complete an experiment by declaring a winning variant. This is a FINAL action — completed experiments cannot be restarted. After completion, all traffic is routed to the winning variant. Valid transitions: running -> completed, paused -> completed. WORKFLOW: Check pictify_get_experiment first to review per-variant impression/click counts, then declare the winner based on data.

Input parameters:

- `experimentId` (string, required): The experiment UID to complete
- `winnerVariantId` (string, required): The ID of the winning variant. Must be one of the experiment's variant IDs. Use pictify_get_experiment to see available variant IDs and their performance.

### `pictify_track_experiment_events` (~118 tokens)

Track impressions, views, clicks, and conversions for experiments. Use this to send event data from your application to Pictify's analytics. Accepts a single event or an array of up to 100 events. Authentication: Uses the API key (Bearer token). For client-side tracking, use the X-Write-Key header or writeKey field instead (safe to expose in browser code). Rate limit: 1000 requests/minute per IP.

Input parameters:

- `events` (array, required): Array of events to track (1-100)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/pictify-io-mcp/mcp#diagnostics

## Score history

- 2026-08-03: 65
- 2026-08-02: 65
- 2026-08-01: 64
- 2026-07-31: 64
- 2026-07-30: 64
- 2026-07-29: 63
- 2026-07-28: 63
- 2026-07-27: 62
- 2026-07-26: 61

## Links

- Remote endpoint: https://mcp.pictify.io/
- Repository: https://github.com/pictify-io/mcp
- Website: https://pictify.io/
- Changelog RSS feed: https://verifymcp.io/servers/pictify-io-mcp/mcp/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/pictify-io-mcp/mcp/changelog.json
- HTML version of this page: https://verifymcp.io/servers/pictify-io-mcp/mcp