PageToVid for AI assistants

shell
claude mcp add --transport http pagetovid https://pagetovid.com/mcp

Run /mcp inside Claude Code and authenticate — a browser opens, you sign in to PageToVid once, and that is it.

Settings → Connectors → Add custom connector → paste https://pagetovid.com/mcp

Claude opens a PageToVid sign-in and asks you to approve access. Custom connectors are available on paid Claude plans.

Opens Cursor and pre-fills the server. Cursor then runs the sign-in for you.

VS Code signs you in on first use. Or add it by hand to .vscode/mcp.json.

json
{
  "servers": {
    "pagetovid": {
      "type": "http",
      "url": "https://pagetovid.com/mcp"
    }
  }
}

toml
[mcp_servers.pagetovid]
url = "https://pagetovid.com/mcp"

Codex runs the sign-in on first use. For a headless agent, add http_headers = { Authorization = "Bearer cp_live_…" } instead.

shell
gemini mcp add --transport http pagetovid https://pagetovid.com/mcp

json
{
  "mcp_servers": [
    {
      "type": "url",
      "url": "https://pagetovid.com/mcp",
      "name": "pagetovid",
      "authorization_token": "YOUR_KEY"
    }
  ]
}

Pass alongside your messages request; the model can then call the tools directly.

json
{
  "mcpServers": {
    "pagetovid": {
      "type": "http",
      "url": "https://pagetovid.com/mcp"
    }
  }
}

The shape most clients accept for a remote Streamable HTTP server. A client that cannot sign in can send an API key header instead — see below.

[40 credits] Starts a PageToVid render that turns a public web page URL into a narrated video with an AI voiceover, motion graphics and optional subtitles. Rendering is asynchronous and usually takes several minutes but can run past fifteen for a heavy page or a busy queue; this returns a video_id immediately, and get_video reports the phase, the progress and an estimate recalculated from how long this particular render has already taken. The page must be publicly reachable — a page behind a login is filmed only when a capture session was registered for the site from the VS Code or browser extension.

[40 credits] Make a video from data. Create, make, generate or render an animated video, explainer, data video or chart video from content you already have — figures, a table, notes, an idea — with NO website and NO URL required. This is the tool for turning numbers or text you are holding into a finished MP4 with narration and captions. You supply the scenes; PageToVid draws each as a motion graphic (charts, big numbers, comparisons, timelines, quotes, title cards), records an AI voiceover, burns captions and renders it. Call list_motions first for the 19 visuals, what each one needs, and the animations it accepts. Rendering is asynchronous: this returns a video_id immediately and get_video reports progress. get_video, get_storyboard, update_storyboard, rerender_video and get_video_embed all work on the result exactly as they do for a filmed video.

[Free] Stops a render that is still running and returns every credit it spent — the render credit and any AI stills or clips it had already generated. Use it the moment get_storyboard shows a plan you do not want: a film takes several minutes, and without this the only option was to watch it finish. A render that has already finished cannot be cancelled, and is reported as such rather than refunded. The worker is not killed mid-frame; it stops at its next step, and the video is marked as cancelled straight away.

[Account] Reports how far a PageToVid render has got and, once it is finished, returns the video, poster and subtitle links. While a render is in progress the result includes a suggested number of seconds to wait before checking again. `status` is one of, in pipeline order: draft, queued, analyzing, scripting, recording, voicing, rendering, done, error. In flight, so poll again after poll_after_seconds: queued, analyzing, scripting, recording, voicing, rendering. Terminal, so stop polling: done, error — a cancelled render ends as error with the reason in `error`, and a film can be done and still carry warnings. draft has not been queued.

[Free] Returns ready-to-paste markup for a finished PageToVid video: an HTML video element, Open Graph and Twitter player meta tags so the page unfurls as a playable video, and a schema.org VideoObject JSON-LD block.

[Free] Every model this account can generate clips and stills with — capabilities, limits and the exact credit price — before spending anything. Omit model in a scene for the house clip; name one (data.model, or set_inset model) to choose it and pay its price. quote_cost prices a specific request.

[Free] What something will cost in credits, spending nothing. Either price one generation — kind clip or image, with an optional model, duration_s, resolution, role (scene or inset) and count — or give a video_id to price its next rerender_video: the render plus every AI visual not yet made. A length or resolution the model does not offer is refused with what it does offer.

[Free] Lists what create_video accepts: goals, aspect ratios, languages, voices, background music beds (eight, each with a family: calm, energetic, serious, playful) and the allowed length range. Static reference data — no account access.

[Free] List animations, motions, visuals and chart types. The catalogue of what a scene can be drawn as — chart, big number, comparison, timeline, checklist, quote, table, title card and twelve more — and the named entrance animations each accepts, grouped by feel (calm, elegant, bold, playful, dramatic, techy). Free, no account access, no credit. Call this before create_animation or update_storyboard so a scene is given a visual and an animation that exist and go together; a mismatched pair is refused, not silently swapped.

[Free] Lists what the theme parameter accepts: the built-in presets, the modes, the type faces the renderer can actually load, and the contrast and palette rules that are enforced before a credit moves. Static reference data — no account access, no page fetched, free.

[Free] Opens a public web page in a real browser and lists what a video could point its camera at, ranked: calls to action, product images, cards, pricing blocks, testimonials, search and chat boxes, headings and sections — each with a CSS selector, a size and a score for how much a viewer wants to look at it. It also says when the browser was shown a robot check, a sign-in or an error page instead of the real one (blocked, block_kind), so a film is never shot on the wall in front of a site. Also lists the text fields that will never be typed into, and why. This is the same ranking the script planner reads when it decides the shots, so it is what to look at before asking for a particular one. No video is made and no credit is spent.

[Free] Opens a public web page in a real browser and reads its design tokens from the live CSS: accent colours, heading typeface, light or dark ground and corner style. Returns a theme object ready to pass to create_video, create_animation or rerender_video, plus any colour the site uses that the film cannot paint with and why. No video is made and no credit is spent.

[Account] CALL THIS FIRST. What this account may do and what it will be charged: the plan, the credits left, whether AI stills and clips are available and whether they cost anything here, whether finished videos carry a watermark, how many renders are running, and the length and rate limits. The usual order after this is inspect_page on each page you might film (in the aspect ratio you will film it in), then create_video or create_animation, then get_storyboard — which is free and is the only place the shots the planner actually chose are visible — then update_storyboard and rerender_video.

[Account] Lists videos newest first with their status and, when finished, their links. Filter by status or by a word in the page URL or title. Returns a cursor when more remain.

[Account] Returns the scene-by-scene plan of a video: what each scene narrates, its on-screen caption, how long it holds, and whether it is real footage of the page or a motion graphic (and which motion).

[Free] Changes a video's storyboard: rewrite what a scene says, change its caption or heading, redraw it as a different visual, correct its data, tint it, point its camera at a specific element of the page (set_shot: a selector from inspect_page with a click, typing, a hover or a spotlight — checked on the live page before the edit is accepted), add a scene, copy one, trim, remove or reorder them, or change the voice or background music. 18 operations, listed on the operations parameter. Costs no credit and does not re-render — call rerender_video to produce a new film from the edited storyboard. Every call is snapshotted, so an edit can be undone in the web editor.

[40 credits] Produces a new film from the video's current storyboard, skipping the page analysis and scripting that create_video does. Consumes one render's credits — except once per video when the finished film missed its own length target (get_video reports length_within_tolerance: false): that correction is ours, and free. With captions_only true it only re-times the subtitles on the film's existing voice track (no re-recording, no new take), free once per render. The previous video file is replaced once the new render finishes.

[Free] Returns the plan for a site: the videos it should have, each with a goal, a pitch, an audience, a ready creative brief and the shots it needs — and, for each, the video already made from it on this account, if any. Generated on first call from the site's own pages (text-only, no credit), stored, and returned as is afterwards. This is the list generate_site_videos works from.

[40 credits] Per video started. Starts a video for each idea in the site's plan (see get_site_plan) that has none yet, or for the idea_ids given. Each is an ordinary filmed video — the idea's brief becomes its focus — and each costs a render when it starts. Called without confirm it only lists what it would make and what that costs; nothing is created. Rendering is asynchronous: get_video reports each one. A retried call does not start the same idea twice.

[Free] A show makes a video from each new item in a feed — the same storyboard every episode, new data every episode: a weekly release video from a changelog, a daily listing video from an RSS feed, a clip per new post. Episodes are ordinary videos (a render each) made by run_show or, once confirmed, by the scheduler at the show's cadence. A new show is HELD: nothing renders until its owner has called run_show once with confirm=true, and it never spends more than max_credits_per_day. Returns the show and what to do next.

[Account] Lists the shows on this account — or one site's — with their cadence, caps, whether each is confirmed or still held, what it spent today, and its five most recent episodes with the video each became.

[40 credits] Per episode started. Reads the show's feed (or the items given), skips every item that already became an episode, and — within max_episodes_per_run and max_credits_per_day — starts one video per new item. Without confirm it returns the list it would make and spends nothing. On a held show, confirm=true is the owner's one-time approval: it makes the episodes and lets the scheduler run the show from then on.

[Free] Changes a show's switch, cadence, caps or name, or moves it to another format or format version. The template itself is edited with update_format, which writes a new version and leaves every episode already made where it is. Nothing is rendered.

[Free] A format is how an episode is made — aspect, language, voice, music, tone, goal, length, cards, brand, theme, the brief or the scene templates — and knows nothing about any subject. It is versioned: update_format writes a new version, shows pin one or follow latest, and every episode records the version that made it. One format can drive several shows. Validated now against a sample item; nothing is rendered.

[Free] Changes any of a format's template fields. The result is a NEW version — the previous ones stay exactly as they were, and every episode already made keeps the version that made it. Shows following latest use the new version from their next run; pinned shows do not move until update_show moves them. Validated whole before anything is written.

[Free] The format's current template, its version history and the shows that run it, with each show's pin.

[Free] The account's formats, newest change first, with versions and the shows running each.

[Free] A new format whose version 1 is the original's latest version, unpinned from its parent. Edit the copy without touching the original.

[Free] Compiles the template against a sample item without touching the database or any feed: the catalogue checks (voice, music, language, theme…), the scene templates filled and checked as an animation, and what the first episode's title, brief and scene count would be. Returns problems by field; nothing is created, rendered or charged.

[Free] Runs the format's resolvers against the item (real upstream calls, cached where the format says so), compiles the storyboard and returns every beat's final text, the beats dropped and why, the integrity report (hand-written numbers, missing required beats, rejections, length against the brief), the upstream calls made with their timing, and where every bound value came from. Nothing is rendered and no credit moves. This is what to read before run_show confirm=true.

[Free] The proof behind a film. Returns the format version that made it (with the template's SHA-256), every resolver source with what it fetched and when, the integrity report and the beats dropped, the storyboard's claim ledger (which figures trace to the page, the brief, or nothing), the Content Credentials written on the render (manifest URL; whether the file is C2PA-signed and by whom), and a reproducibility check: the stored data is recompiled with the same format version and compared to the rendered narration word for word. Nothing is rendered and nothing is charged.

[Free] Registers (or replaces) a connection by alias: the URL and, optionally, a credential kept encrypted on this account. Formats refer to the alias only, so a format never carries a secret and is safe to publish or fork. Nothing is called now.

[Free or 40 credits] Names a character so a generated clip that names it keeps the same identity across scenes (Veo 3.1 ingredients-to-video). Give refs — 1 to 3 reference image URLs on this account — or a generate prompt to DRAW the reference here (40 credits, refunded if it fails; naming a character from refs you already have is free). Then set an animation image scene's data.clip=true and data.character="<name>" to make a moving beat with that character. Building one from a film you already made: take a scene's raw_frame_url from get_storyboard, never its thumbnail_url — the thumbnail is cut from the finished video and carries the headline and caption burnt into the picture, and a reference image with text in it teaches the generator to draw text.

[Free] The reusable characters on this account, each with its reference images and description. Credentials are never involved; these are just image references.

[Free] Media people shared from their banks for anyone to use in a film — logos, product shots, illustrations, recorded flows — with tags, a licence and the site to credit. An image scene of create_animation or update_storyboard takes an asset's id as data.asset_id (or its url as imageUrl); a gallery takes urls. Nothing here is private: only assets their owners switched to shared.

[40 or 160 credits] Generates a single AI still (40 credits) or house clip (160 credits) straight into your media bank and returns its id and URL — no project, no render, no minimum length. Use it for character reference portraits, or for any visual you want to see before it goes into a film. The charge is taken before the call and refunded automatically if the generation fails; identical output is de-duplicated, so a repeat does not cost a second file. Generation is a paid-plan feature.

[Free] Your PRIVATE bank: every image and clip this account generated, uploaded or captured, newest first, with its id, URL, brief and tags. list_commons_assets only shows what other people shared, so anything you generated yourself was invisible. Reuse one by putting its id in an image scene as data.asset_id — a clip resolves to clipUrl by itself, and a URL still works. Reusing costs no credit and generates nothing.

[Free] Every registered connection with its alias, kind and URL. Credentials are never returned.