# Latchshot integration recipes

These recipes use the hosted Latchshot API directly. Store the API key in the automation platform's secret or credential manager; never commit it to a workflow file.

## Supabase Edge Functions

The [Supabase Edge Function screenshot guide](https://latchshot.fly.dev/guides/supabase-edge-function-screenshot.html) provides a complete Deno/TypeScript capture-and-store core. It keeps the Latchshot and service-role keys in Edge Function secrets, returns direct PNG bytes from one provider request, validates the content type, and uploads only successful captures to an application-owned Supabase Storage bucket.

Authenticate the caller and confirm workspace/project access before invoking that helper. Use a private bucket plus short-lived signed Storage URLs unless public delivery is an explicit product decision. The guide maps the common ScreenshotOne JSON-URL/two-fetch path to Latchshot's direct-byte response and identifies the sectional full-page, hosted-artifact, custom-page-action, and anti-bot jobs that should not migrate.

## ApiFlash migration

For server-side synchronous public-page PNG or JPEG captures, use the [ApiFlash-to-Latchshot migration guide](https://latchshot.fly.dev/guides/migrate-from-apiflash.html) to move the query/form credential into a Bearer header, preserve direct binary output, translate viewport and wait controls, and convert delay units. Keep ApiFlash when the job depends on provider caching, a hosted JSON URL, WebP, selectors, page modification, extraction, proxies, or S3 delivery.

This is an interoperability guide, not a claim of ApiFlash affiliation or a universal drop-in replacement.

## ScreenshotMachine migration

For trusted-server synchronous public-page PNG or JPEG captures, use the [ScreenshotMachine-to-Latchshot migration guide](https://latchshot.fly.dev/guides/migrate-from-screenshotmachine.html) to move the query credential into a Bearer header, split dimensions, preserve binary output, translate full-page and delay controls, and replace error-image handling. Keep ScreenshotMachine when the job depends on a signed image URL, provider caching, GIF, device presets, page changes, cookies, custom headers, element capture, or region cropping.

This is an interoperability guide, not a claim of ScreenshotMachine affiliation or a universal drop-in replacement.

## Urlbox migration

For server-side synchronous public-page captures, use the [Urlbox-to-Latchshot migration guide](https://latchshot.fly.dev/guides/migrate-from-urlbox.html) to preserve Bearer authentication, translate viewport, output, wait, dark-mode, and PDF controls, and account for Latchshot's direct binary response. Keep Urlbox when the job depends on signed render links, temporary hosted URLs, provider caching, async delivery, storage, selectors, page modification, proxies, or other Urlbox-only features.

This is an interoperability guide, not a claim of Urlbox affiliation or a universal drop-in replacement.

## ScreenshotOne migration

For synchronous public-page captures, use the [ScreenshotOne-to-Latchshot migration guide](https://latchshot.fly.dev/guides/migrate-from-screenshotone.html) to move the query credential into a Bearer header, translate viewport and output controls, convert delay and timeout units, map the five bounded cleanup controls, and run a representative comparison set. The guide also identifies jobs that should stay on ScreenshotOne because they require custom/exhaustive blockers, selectors, scripts, proxies, hosted artifact URLs, caching, S3 upload, or async webhooks.

This is an interoperability guide, not a claim of ScreenshotOne affiliation or a universal drop-in replacement.

## Browserless migration

For synchronous screenshots of one public URL, use the [Browserless-to-Latchshot migration guide](https://latchshot.fly.dev/guides/migrate-from-browserless.html) to move the query token into a Bearer header, preserve direct PNG or JPEG bytes, and translate viewport, quality, full-page, lifecycle-wait, timeout, and delay controls. Keep Browserless when the job sends inline HTML, uses CDP, Puppeteer, Playwright, BrowserQL, or functions, supplies headers, cookies, login state, scripts, selectors, clip coordinates, or scrolling, reaches private targets, or depends on proxies and browser regions.

This is an interoperability guide, not a claim of Browserless affiliation or a universal drop-in replacement.

## MCP clients

Connect an MCP Streamable HTTP client to `https://latchshot.fly.dev/mcp` and configure the secret header `Authorization: Bearer ls_live_...`. The hosted server exposes `capture_page` for inline PNG, JPEG, and PDF captures and `get_usage` for plan and quota status. It needs no local browser or package installation and applies the same public-target guard, successful-render quota, and diagnostics as the REST API.

The [MCP configuration and tool contract](https://latchshot.fly.dev/docs.md#hosted-mcp-server) and [public remote-server metadata](https://github.com/BaiqingL/latchshot-mcp) include a representative client configuration. The server is active in the official MCP Registry as `io.github.BaiqingL/latchshot`. MCP clients differ in how they interpolate environment variables, so store the complete header value through the specific client's credential mechanism rather than committing a key to a config repository.

## Open Connector

[Open Connector](https://github.com/oomol-lab/open-connector) upstream `main` includes a native Latchshot provider. For a source build from current `main`, create a [recurring Free-plan key](https://latchshot.fly.dev/?intent=openconnector#trial), add the **Latchshot** provider, and save only the token beginning with `ls_live_...` in its API Key credential field. The provider sends that value as a Bearer token to the fixed `https://latchshot.fly.dev` origin.

Use `capture_page` to render a public HTTP or HTTPS page as a PNG, JPEG, or PDF. The provider writes the bounded response to Open Connector's local transit storage and returns the file reference, render diagnostics, and remaining quota. Use the read-only `get_usage` action to inspect plan, quota, reset time, any existing paid-plan request, and owner-managed links to the public plans, human request form, and authenticated request documentation. Neither action starts a payment or changes the plan.

The [accepted provider contribution](https://github.com/oomol-lab/open-connector/pull/151) contains the complete action schemas, credential validation, bounded response handling, and tests. The [accepted continuation change](https://github.com/oomol-lab/open-connector/pull/155) passes through all three stable links while preserving the two-action, no-payment boundary. Both changes are on upstream `main` with passing CI. The latest stable release, v1.3.0 from July 17, predates both Latchshot merges, and the public OOMOL catalog does not currently contain a Latchshot record. Use a reviewed current-source build or wait for a later Open Connector release; source acceptance is not evidence of a released package, installation, user, customer, or endorsement.

## VS Code and GitHub Copilot

VS Code can install Latchshot as a remote MCP server without a local package or browser. First create a [recurring Free-plan key](https://latchshot.fly.dev/?intent=vscode#trial), then use the secure install definition below. VS Code prompts for the key on first start, hides the typed value, and stores it through its input-variable secret path.

[Install Latchshot in VS Code](vscode:mcp/install?%7B%22name%22%3A%22latchshot%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Flatchshot.fly.dev%2Fmcp%22%2C%22headers%22%3A%7B%22Authorization%22%3A%22Bearer%20%24%7Binput%3Alatchshot-api-key%7D%22%7D%2C%22inputs%22%3A%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22latchshot-api-key%22%2C%22description%22%3A%22Latchshot%20API%20key%22%2C%22password%22%3Atrue%7D%5D%7D)

The equivalent current CLI command is:

```sh
code --add-mcp '{"name":"latchshot","type":"http","url":"https://latchshot.fly.dev/mcp","headers":{"Authorization":"Bearer ${input:latchshot-api-key}"},"inputs":[{"type":"promptString","id":"latchshot-api-key","description":"Latchshot API key","password":true}]}'
```

The same reviewed definition is available as [`vscode-mcp.json`](https://latchshot.fly.dev/integrations/vscode-mcp.json). After installation, start `latchshot` from **MCP: List Servers**, enter the key when prompted, and enable `capture_page` or `get_usage` through **Configure Tools** in chat.

VS Code 1.129.1's CLI accepted the definition and wrote the exact fixed endpoint, header placeholder, and password input into a clean profile. Its current MCP content model includes inline images and embedded resources; this configuration check did not use or claim a GitHub Copilot account or model invocation.

Latchshot `v1.0.1` is active in the official MCP Community Registry with its verified public repository ID. GitHub documents that Community Registry entries flow into its MCP Registry and VS Code gallery, but Latchshot is not yet returned by the live GitHub MCP Registry search. Direct installation does not depend on that downstream sync, and no GitHub or Microsoft listing acceptance is claimed yet.

## Cursor

Cursor can install Latchshot as an authenticated remote MCP server without a local package or browser. First [create a recurring Free-plan key](https://latchshot.fly.dev/?intent=cursor#trial), store it in the environment that launches Cursor, and restart Cursor from that environment:

```sh
export LATCHSHOT_API_KEY='ls_live_replace_me'
```

[Install Latchshot in Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=latchshot&config=eyJ1cmwiOiJodHRwczovL2xhdGNoc2hvdC5mbHkuZGV2L21jcCIsImhlYWRlcnMiOnsiQXV0aG9yaXphdGlvbiI6IkJlYXJlciAke2VudjpMQVRDSFNIT1RfQVBJX0tFWX0ifX0%3D)

The equivalent current CLI command is:

```sh
cursor --add-mcp '{"name":"latchshot","url":"https://latchshot.fly.dev/mcp","headers":{"Authorization":"Bearer ${env:LATCHSHOT_API_KEY}"}}'
```

The reviewed user-level configuration is available as [`cursor-mcp.json`](https://latchshot.fly.dev/integrations/cursor-mcp.json). Cursor's one-click link contains only the fixed endpoint and the environment-variable placeholder—not the key. Keep `LATCHSHOT_API_KEY` in a protected shell or system environment and do not replace the placeholder with plaintext in a project file.

Cursor 3.12.17's native `--add-mcp` command accepted the exact definition in a clean profile and wrote the fixed URL and header interpolation under `mcp.servers.latchshot`. Current Cursor documentation explicitly supports remote HTTP/SSE headers, `${env:NAME}` interpolation in headers, MCP resources, and returned images as chat context. This configuration check used no Cursor account or agent/model invocation.

After installation, open **Customize → MCP**, confirm `latchshot`, and call `get_usage` before a capture. Latchshot is not claimed as a Cursor Marketplace listing, official plugin, external install, user, or customer; direct installation does not depend on marketplace review.

## goose

goose can use Latchshot today as a custom Remote Extension over Streamable HTTP. First [create a recurring Free-plan key](https://latchshot.fly.dev/?intent=goose#trial), then add a `Remote Extension (Streamable HTTP)` with:

```text
Endpoint URL: https://latchshot.fly.dev/mcp
Custom Request Header: Authorization: Bearer <YOUR_LATCHSHOT_API_KEY>
```

Keep the complete header value in goose's extension configuration. Do not use the generated `goose session --with-streamable-http-extension` command for Latchshot: that URL-only shortcut cannot carry the required authorization header.

After connecting, use `get_usage` to confirm the key and `capture_page` to request a PNG, JPEG, or PDF of a public page. A live goose 1.43.0 check discovered both tools and captured `https://example.com` as an 800×450 PNG: 15,155 bytes in 450 ms, with navigation complete, original fonts, active scripts, and the expected quota decrement. Artifact size and timing vary by page.

The [goose directory and setup-guide contribution](https://github.com/aaif-goose/goose/pull/10567) is under maintainer review. Manual authenticated setup does not depend on that contribution being merged.

## Claude Code

The public [Latchshot Claude Code plugin](https://github.com/BaiqingL/latchshot-claude-code) adds the hosted MCP server without executable code, hooks, agents, or always-on prompt content. It requires Claude Code 2.1.154 or newer and reads the key from the environment that launches Claude Code:

```sh
export LATCHSHOT_API_KEY='ls_live_replace_me'
claude plugin marketplace add BaiqingL/latchshot-claude-code
claude plugin install latchshot@latchshot
claude plugin enable latchshot@latchshot
```

Create a [recurring Free-plan key](https://latchshot.fly.dev/?intent=claudecode#trial), restart Claude Code from that environment or run `/reload-plugins`, then inspect `/mcp`. Keep the key in a shell secret manager or protected environment configuration rather than a project file.

The immutable [`v1.0.0` release](https://github.com/BaiqingL/latchshot-claude-code/releases/tag/v1.0.0) passes its four contract tests and Claude Code's strict plugin and marketplace validators. A clean Claude Code 2.1.215 install cloned the public repository, reported zero skills/agents/hooks and one MCP server, added approximately zero always-on prompt tokens, and connected to production. The bounded QA key was revoked immediately without a render or activation.

The repository is directly installable now. It has not been accepted into Anthropic's community marketplace, and no such acceptance or affiliation is claimed.

## Gemini CLI

The public [Latchshot Gemini CLI extension](https://github.com/BaiqingL/latchshot-gemini-cli) adds the hosted MCP server without executable code, hooks, commands, skills, agents, or always-on prompt content. Gemini CLI stores its declared `LATCHSHOT_API_KEY` setting through the sensitive extension-settings path and injects it only into the fixed HTTPS authorization header.

Create a [recurring Free-plan key](https://latchshot.fly.dev/?intent=geminicli#trial), then install from the public repository:

```sh
gemini extensions install https://github.com/BaiqingL/latchshot-gemini-cli
```

Review the manifest when prompted, enter the key, and restart Gemini CLI. Run `/extensions list` or `gemini extensions list` to inspect the extension. Do not use `--skip-settings` during ordinary installation.

The immutable [`v1.0.0` release](https://github.com/BaiqingL/latchshot-gemini-cli/releases/tag/v1.0.0) passes four contract tests, Gemini CLI 0.51.0's native extension validator, and its public validation workflow. A bounded live check discovered both tools and captured `https://example.com` as an 800×450 PNG: 15,155 bytes in 413 ms, with navigation complete, original fonts, active scripts, and the expected quota decrement. A separate clean install cloned the public repository, connected to production, and called `get_usage` without a render. Both disposable keys were revoked immediately.

The repository has the official `gemini-cli-extension` discovery topic and a root manifest, but it is not yet present in the live gallery index. Gemini's crawler runs daily. Direct installation from GitHub does not depend on gallery discovery. No Google approval, affiliation, or gallery acceptance is claimed.

## Dify

The public [Latchshot for Dify package](https://github.com/BaiqingL/latchshot-dify/releases/tag/v0.0.1) adds `capture_page` and `get_usage` to Dify Workflows and Agents. Download the `.difypkg`, install it through Dify's local-package flow, and add the Latchshot key as a secret provider credential. The plugin fixes the API endpoint to `https://latchshot.fly.dev`, returns PNG/JPEG/PDF artifacts directly, and does not expose payment or upgrade actions.

The [Dify website screenshot tool guide](https://latchshot.fly.dev/guides/dify-website-screenshot-tool.html) covers package verification, installation, workflow inputs, blob and diagnostic outputs, network/data boundaries, and the distinction between package tests and an unverified Dify Cloud installation. The source is MIT licensed; the hosted renderer remains a separate quota-metered service.

## Archestra

Archestra operators can add Latchshot through the product's manual private-registry path: choose **Start from scratch**, select a **Remote** server, set `https://latchshot.fly.dev/mcp`, and choose **Token header** authentication. Keep the generated `Authorization` header installation-scoped, required, sensitive, and configured to prepend `Bearer `. Paste only the `ls_live_...` token when the connection-test installation prompt asks for the value.

The [Archestra screenshot MCP server guide](https://latchshot.fly.dev/guides/archestra-screenshot-mcp-server.html) covers the exact fields, credential boundary, tool review, guardrails, first call, and failure handling. Archestra's public catalog API returned no Latchshot result on July 19, 2026, so this manual path does not claim an online-catalog listing, Archestra endorsement, install, or user.

## CLI and Node.js

The public [Latchshot CLI and Node client](https://github.com/BaiqingL/latchshot-cli) packages screenshot, PDF, usage, paid-plan request, and health commands without runtime dependencies. It runs directly from its immutable GitHub release:

```sh
export LATCHSHOT_API_KEY='ls_live_replace_me'
npx --yes github:BaiqingL/latchshot-cli#v0.2.1 \
  capture https://example.com example.png
```

The same package exports `LatchshotClient` for Node.js 18.17 or newer. It is not published to npm; the complete GitHub package spec is required.

An existing Free-plan key can request a higher paid plan without leaving the terminal. Contact consent is mandatory for this upgrade request, no payment is taken by the command, and the key remains unchanged after owner-confirmed activation:

```sh
npx --yes github:BaiqingL/latchshot-cli#v0.2.1 \
  upgrade build --consent-contact
```

## GitHub Actions

Use Latchshot to attach a current webpage capture to a workflow run—for example, a documentation preview, release evidence, or a public QA artifact.

1. Add `LATCHSHOT_API_KEY` as an Actions repository secret.
2. Use the public [`BaiqingL/latchshot-action@v1`](https://github.com/BaiqingL/latchshot-action) action in a workflow.
3. Upload the returned path as an artifact or pass it to the next job step.

```yaml
- id: screenshot
  uses: BaiqingL/latchshot-action@v1
  with:
    api_key: ${{ secrets.LATCHSHOT_API_KEY }}
    url: https://example.com
    output: webpage.png
```

The repository includes a [complete manually triggered workflow](https://github.com/BaiqingL/latchshot-action/blob/main/.github/workflows/capture-page.yml), dependency-free Node and Python clients, bounded retries, output diagnostics, MIT-licensed integration code, and a passing validation workflow. The original [single-file curl workflow](https://latchshot.fly.dev/integrations/github-actions.yml) remains available when a reusable action is unnecessary.

The [website screenshot GitHub Action guide](https://latchshot.fly.dev/guides/website-screenshot-github-action.html) covers the copy-paste workflow, repository secret, artifact outputs, schedules, and the decision between hosted rendering and a browser in the runner.

## n8n

The [n8n HTTP Request recipe](https://latchshot.fly.dev/integrations/n8n.md) returns the screenshot as binary data for storage, email, or a later workflow node. It uses n8n's Bearer credential store rather than embedding the key in an exported workflow.

For an importable path, download immutable [workflow release v1.0.1](https://github.com/BaiqingL/latchshot-n8n/releases/tag/v1.0.1), use the checksum-matched [Awesome n8n Templates community copy](https://github.com/enescingoz/awesome-n8n-templates/blob/main/Other_Integrations_and_Use_Cases/Latchshot%20%E2%80%94%20capture%20a%20public%20webpage.json), or use the byte-identical [production-hosted copy](https://latchshot.fly.dev/integrations/n8n-website-screenshot.json). The community catalog is independent and is not an official n8n Marketplace endorsement. The public MIT repository includes a dependency-free validator and passing CI. The workflow contains a manual trigger, typed starter inputs, a direct recurring-Free credential link, and one HTTP Request 4.4 node that writes the response to binary field `capture`. The [n8n website screenshot workflow guide](https://latchshot.fly.dev/guides/n8n-website-screenshot-workflow.html) covers import, credentials, binary routing, the PDF variant, retries, and the public-network boundary. It was imported and executed against n8n 2.30.7; the controlled production run returned a valid 17,883-byte 1440×900 PNG.

## Scheduled reports

The [scheduled-report recipe](https://latchshot.fly.dev/integrations/scheduled-reports.md) shows a bounded capture job, quota check, and cron/CI operating rules. It is intended for public dashboards, reports, and documentation—not authenticated or private pages.

## Existing screenshot provider

Use the [migration option map](https://latchshot.fly.dev/migrate.md) and test a representative sample before routing production traffic. Latchshot deliberately omits arbitrary browser scripts, cookies, private-network access, CAPTCHA solving, and proxy rotation.

The [URL-to-screenshot guide](https://latchshot.fly.dev/guides/url-to-screenshot-api.html), [website-thumbnail guide](https://latchshot.fly.dev/guides/website-thumbnail-api.html), [Supabase Edge Function guide](https://latchshot.fly.dev/guides/supabase-edge-function-screenshot.html), and [URL-to-PDF guide](https://latchshot.fly.dev/guides/url-to-pdf-api.html) show the direct request contract before it is wrapped in an automation platform. The thumbnail guide adds storage, refresh, and fallback decisions; the Supabase guide provides the secret-safe Deno and Storage implementation.

If the current implementation runs Chromium directly, use the [screenshot API vs Playwright decision guide](https://latchshot.fly.dev/guides/screenshot-api-vs-playwright.html) to separate bounded public-page artifacts from authenticated, private, or interactive browser work before migrating.

## Screenshot API product backend

If your product already authenticates customers, checks a cache, stores image bytes, returns a CDN URL, enforces plan quotas, and handles checkout, use the [screenshot API backend guide](https://latchshot.fly.dev/guides/screenshot-api-backend.html) to isolate the one compatible upstream seam. The pattern keeps customer identity, artifacts, delivery, usage accounting, billing, and support inside your application while Latchshot handles only synchronous public-URL PNG or JPEG rendering.

Keep the current provider for hosted or signed image URLs, async jobs, webhooks, provider storage, sessions, scripts, actions, scrolling, private targets, proxy placement, video, and other stop-list behavior. The guide includes a server-only Node request, artifact validation, responsibility map, full-allowance unit-cost inputs, failure mapping, rollout tests, and the optional bounded implementation-pilot path. It does not claim reseller adoption or guaranteed margin.

Get a Free-plan key with 100 successful renders each UTC calendar month through the [developer documentation](https://latchshot.fly.dev/docs.md#get-100-free-renders-each-month).