# MCP server for OG images, screenshots and bulk renders

> Connect Claude, ChatGPT, Cursor, Claude Code or VS Code to one remote MCP server that renders social images, takes screenshots and runs bulk jobs.

Published 2026-11-04 · https://shareglint.com/en/mcp-server

Shareglint runs a **remote MCP server** at `https://shareglint.com/mcp`. Add that one URL to Claude, ChatGPT, Cursor, Claude Code or VS Code and the assistant can render Open Graph and social images from templates, take screenshots of web pages, run bulk jobs from a spreadsheet and build `og:image` URLs for your site — on the same account, templates and quota as the [REST API](https://shareglint.com/en/docs). Nothing runs on your machine: the server speaks the Model Context Protocol's Streamable HTTP transport and authenticates with OAuth or an API key.

## Two ways in, one account

| Client | How it connects | Setup |
|---|---|---|
| Claude (web, desktop, mobile) | Custom connector, OAuth sign-in | [Claude](https://shareglint.com/en/mcp/claude) |
| ChatGPT | Custom MCP server, OAuth sign-in | [ChatGPT](https://shareglint.com/en/mcp/chatgpt) |
| Cursor | `mcp.json` with the URL and a Bearer header | [Cursor](https://shareglint.com/en/mcp/cursor) |
| Claude Code | `claude mcp add --transport http` with a header | [Claude Code](https://shareglint.com/en/mcp/claude-code) |
| VS Code | `.vscode/mcp.json`, key from an input prompt | [VS Code](https://shareglint.com/en/mcp/vscode) |

Chat apps cannot send an API key, so they sign in: the server supports OAuth 2.1 with dynamic client registration and PKCE, and a chat app registers itself, sends you to the Shareglint login and a consent screen, and gets a token. Connected apps appear in your account settings, where you can disconnect one at any time. Coding tools and your own code send `Authorization: Bearer sk_live_...` instead. Either way the calls land on the same workspace.

The protocol itself is described at [modelcontextprotocol.io](https://modelcontextprotocol.io/specification/latest), and its [authorization spec](https://modelcontextprotocol.io/specification/latest/basic/authorization) covers the OAuth flow; clients discover the OAuth metadata at `https://shareglint.com/.well-known/oauth-protected-resource/mcp`.

## The tools

The server lists these tools (`tools/list`): `render_image`, `get_image`, `list_templates`, `get_template`, `create_signed_url`, `get_usage`, `generate_template`, `take_screenshot`, `auto_og_url`, `create_batch`, `get_batch`. What they do, grouped by job:

- **Render from a template.** `render_image` takes a template — one of your own or one of the 153 built-in ones — and field values, and returns the image URL; `size` or `sizes` gives the same design in other formats (og 1200×630, square 1080×1080, portrait 1080×1350, story 1080×1920, pinterest 1000×1500, youtube 1280×720). `get_image` checks a render that is still queued. `list_templates` and `get_template` show what can be rendered and which fields each template takes.
- **og:image without a server.** `create_signed_url` builds a signed `/i/` URL to paste into a `<meta property="og:image">` tag; it renders on the first request and uses no quota until then. `auto_og_url` builds the one-tag-for-the-whole-site URL for a domain you allowed.
- **Screenshots.** `take_screenshot` captures a public page as PNG, JPEG, WebP or PDF — the viewport, the full page or one element — with device presets, dark mode and cookie-banner and ad blocking, or records a scroll video.
- **Bulk.** `create_batch` renders a template for every row of a JSON array or a public CSV / Google Sheets link; `get_batch` reports progress, each row's URL and the ZIP of all files. Rows per job by plan: Free 50, Starter 500, Pro 1,000, Scale 2,000, Business 5,000.
- **Account.** `get_usage` shows the plan and the renders used and left this month.
- **AI templates.** `generate_template` (paid plans) designs a 1200×630 template from a description or a screenshot and returns a free preview; with `save` it is stored for `render_image`.

## What people ask it to do

Prompts that map straight onto the tools:

- "Make an OG image for this post with the blog-og template: title 'How we cut our build time in half', author Anna." → `render_image`.
- "Add og:image to every page of this Next.js app with a signed URL, using site-card." → the coding agent edits `generateMetadata` and calls `create_signed_url` for the format.
- "Screenshot pricing pages of these three competitors, full page, with cookie banners removed." → three `take_screenshot` calls.
- "Here is a sheet of 120 speakers; render a square card for each and give me the ZIP." → `create_batch`, then `get_batch`.
- "How many renders do I have left this month?" → `get_usage`.

The assistant picks tools from their descriptions; naming the template slug and the size in the prompt makes the first call right more often. The [MCP guide](https://shareglint.com/en/guides/og-images-with-ai-assistants-mcp) has more prompts and how agents behave with them.

## Cost and limits

Tool calls follow the same rules as the REST API. A new render or screenshot uses quota — a viewport screenshot 1, a full page 2, an animated GIF or MP4 5 — and an identical repeat returns the existing file for free. Listing templates, reading one, signing a URL and checking usage cost nothing. When the quota runs out, render tools return the API's quota error (the body of its `402`), and the assistant tells you; nothing is charged automatically. The Free plan has 100 images a month with a watermark; Starter is $9 for 2,000 ([pricing](https://shareglint.com/en/pricing)).

## Safety notes

- **Keys stay out of chat.** Chat apps never see an API key — they hold an OAuth token you can revoke. For coding tools, keep the key in an environment variable or an input prompt, not in a committed config file.
- **Screenshots reach only public pages.** The screenshot browser runs on an isolated network with an egress proxy that allows public addresses on ports 80 and 443 only, so an agent cannot point it at your intranet or a cloud metadata address.
- **Templates are sandboxed.** Template HTML renders in a browser with no network access; images come in through fields the server fetches with the same public-address rules.

## Why an MCP server and not just the API

The API is still there and is what your production code should call. The MCP server is for the work around it: designing and trying a template in conversation, wiring `og:image` into a codebase with an agent, a one-off batch from a spreadsheet, or a set of screenshots for a report — without writing the HTTP calls yourself. Both read the same templates, so a template an assistant designed is the one your code renders later.

## FAQ

### What is the server URL?

One remote URL for every client, over Streamable HTTP. Chat apps add it as a custom connector and sign in with OAuth; coding tools and code send an Authorization: Bearer header with an API key. Both use the same account and quota.

### Does it need a paid plan?

No. Every plan, the Free plan included, can connect and use the tools; images rendered on Free carry the watermark. Only generate_template, which designs a template with AI, is limited to paid plans.

### Which tools does it expose?

Rendering an image from a template, checking a render, listing and reading templates, building signed and auto OG image URLs, taking website screenshots, running and checking bulk jobs from rows or a CSV, showing usage, and, on paid plans, generating a template with AI.

### Do tool calls cost quota?

Only the ones that make a new file, exactly like the REST API: a render or a screenshot uses quota, an identical repeat is free, and listing, reading, signing URLs and checking usage cost nothing.

### Can I run the server locally?

There is nothing to install: it is a hosted remote server. Clients connect to its URL; no npm package or local process is involved.
