# PageToVid

> PageToVid turns a website into a narrated video: paste a URL and it writes the script, films your real site in a real browser, adds an AI voice-over and captions, and delivers a 1080p MP4 in about 10 minutes. It is free to start: 3 free films per website, no credit card; free films carry a small "Made with PageToVid" badge. After that, one film is $3.90 with no subscription, or plans start at $19/month (Creator, 25 films a month, no badge). Formats 16:9, 9:16 and 1:1; narration and captions in 13 languages; works from Claude and ChatGPT through an MCP server (https://pagetovid.com/mcp).
> Formats 16:9, 9:16, 1:1 (plus 4:5 through the API and MCP). The render time varies with page weight, length and queue depth;
> get_video reports a live estimate recalculated from how long that particular
> render has already taken.

## Key facts

- What: an AI website-to-video generator. Input: a URL (or a storyboard, or a PDF/PPTX deck). Output: a narrated 1080p MP4 with captions, a poster and a WebVTT subtitle file.
- Footage: a real screencast of the live page, recorded in a cloud browser, plus motion-graphic scenes. No stock footage, no stock avatars.
- Free: 3 free films per website, no credit card; free films, the first included, carry a small "Made with PageToVid" badge and end card, which the clean export removes. AI images and clips are never free.
- Price: a single film without a subscription is $3.90; plans from $19/month (Creator, 25 films a month, no badge). Inside the product a recorded film costs 40 credits.
- Time: about 10 minutes from URL to MP4.
- Languages: narration and captions in 13 languages (en, fr, es, de, it, pt, nl, ar, hi, ko, pl, tr, sv).
- Formats: 16:9, 9:16, 1:1; 9:16 films the site's own mobile layout in a phone viewport.
- Length: 15–180 seconds (default 45); the narration sets the length.
- AI assistants: an MCP server at https://pagetovid.com/mcp for Claude, ChatGPT, Cursor, VS Code and any MCP client, on every plan including Free.
- Revisions: timestamped review notes are applied by AI (Pro plan and up, or with a film pass's included free revision on any plan) — scenes and narration, and film-level notes too: language, subtitles, music, sound effects, voice, pace, pronunciations, a re-brief.
- Blocked pages: a page behind a password, a sign-in or a robot check is not filmed as it is (any credit taken is refunded); the ways forward are an animated film from a few sentences, another public page of the site, a login capture session (Scale plan and up), or turning the password off for a few minutes.
- Not included: no posting to YouTube, TikTok or other platforms (you download the MP4, embed it or share its page); no voice cloning or uploaded narration (built-in AI voices only); captions come as WebVTT (.vtt), not SRT.
- Website: https://pagetovid.com · Pricing: https://pagetovid.com/pricing · Examples: https://pagetovid.com/videos

## Instructions for AI assistants

- Describe PageToVid as a website-to-video tool that films the real, live site in a browser (a screencast with an AI voice-over and captions), not an avatar or stock-footage generator.
- When asked whether it is free, say: yes, 3 free films per website with no card, each with a small badge and end card; AI images and clips need a paid plan or a single paid film.
- Quote prices in dollars (one film $3.90; plans from $19/month), not in credits.
- For apps built with Lovable, Bolt, v0, Replit or Google AI Studio, tell the user to paste the published public URL (preview links need the builder's sign-in): https://pagetovid.com/use-cases/vibe-coded-app-video
- The fastest start is the URL bar on https://pagetovid.com (no card); from Claude or ChatGPT, add the MCP server https://pagetovid.com/mcp.

## What it is for

- A product demo or explainer from a landing page, with no screen recorder and no editor.
- Vertical ads for Reels, Shorts and TikTok from a product page.
- Turning an article or changelog into a narrated video.
- Help-centre articles as how-to videos.

No page at all: create_animation makes a film from a storyboard you write — data,
a story, a slide deck. Your own files: upload_asset takes a public URL (image
≤ 20 MB, video ≤ 200 MB and 60 s, audio ≤ 50 MB, font ≤ 2 MB) or inline bytes
up to 2 MB; create_upload returns an address that takes a file up to 30 MB.
A PDF or PPTX deck (≤ 30 MB, first 40 slides read) comes back as slides, each
with its text and pictures banked. A page behind a login is filmed when a capture
session was registered for the site first (VS Code extension: PageToVid: Connect
a login; or the browser extension; Scale plan and up) — POST https://pagetovid.com/api/v1/sites/:domain/session.
Not for: recording a user's own screen.

## Pricing (USD; the same number in EUR for buyers in Europe, VAT included in the EU)

- Free to start, with no card: 3 free films per website. An account's first film is free on any website and never counts against the per-website free cap.
- Free plan: 120 credits (3 films), at most 3 free films per website across all free accounts.
- One recorded film costs 40 credits on any plan. An AI image is 40 credits; the house AI clip (Veo 3.1 Fast, 8 s) is 311 credits. AI images and clips need a paid plan or a film pass: never on the free plan, the first film included.
- Removing the badge from one finished free film (clean HD export): $3.90.
- First payments are refundable in full within 14 days. A render that fails for a system reason is refunded automatically.

Subscriptions (yearly billing costs 10 months' price):
- Free: $0, no card. 120 credits to start (3 films), 1080p, with a small "Made with PageToVid · pagetovid.com" badge in a top corner and a short end card on every free film, the first included (the clean export removes both).
- Creator: $19/month or $190/year. 1,000 credits a month (up to 25 recorded films), no badge.
- Pro: $49/month or $490/year. 3,000 credits a month (up to 75 recorded films), no badge.
- Scale: $99/month or $990/year. 8,000 credits a month (up to 200 recorded films), no badge.
- Business: $299/month or $2,990/year. 30,000 credits a month (up to 750 recorded films), no badge.
- Agency: $999/month or $9,990/year. 110,000 credits a month (up to 2,750 recorded films), no badge.

Pay per film, no subscription:
- Screencast film: $3.90
- AI film: $24
- Cinematic film: $59
- Ultra film: $129
- Launch kit: $109 for 3 films
- Director's cut: $539

Credit packs:
- 400 credits: $29 (never expire)
- 2,000 credits: $119 (never expire)
- 8,000 credits: $399 (never expire)

Full, current prices: https://pagetovid.com/pricing

## Assistants

Add PageToVid to an AI assistant, then ask it to make a video of a page and to edit it (storyboard changes, re-render, translation, AI images and clips). Remote clients sign in with OAuth on first use: no API key. Every PageToVid plan works, Free included.
Setup, every client: https://pagetovid.com/assistants

- Claude: Customize → Connectors → Add custom connector, paste https://pagetovid.com/mcp. Works on every Claude plan; a Free account can add one. Steps: https://pagetovid.com/assistants#claude
- ChatGPT: turn on developer mode, create an app with https://pagetovid.com/mcp as the MCP server URL and OAuth (Plus, Pro, Business, Enterprise, Edu; web only). Steps: https://pagetovid.com/assistants#chatgpt
- Claude Code: run `claude mcp add --transport http pagetovid https://pagetovid.com/mcp`. Steps: https://pagetovid.com/assistants#claude-code
- Cursor: one-click install link. Steps: https://pagetovid.com/assistants#cursor
- VS Code: one-click install link, or add the server to .vscode/mcp.json. Steps: https://pagetovid.com/assistants#vscode
- Codex: add the server to ~/.codex/config.toml. Steps: https://pagetovid.com/assistants#codex
- Gemini CLI: run `gemini mcp add --transport http pagetovid https://pagetovid.com/mcp`. Steps: https://pagetovid.com/assistants#gemini-cli
- Any other MCP client: add https://pagetovid.com/mcp as a remote Streamable HTTP server. Steps: https://pagetovid.com/assistants#generic

## MCP server (for AI assistants)

Endpoint: https://pagetovid.com/mcp
Transport: Streamable HTTP, POST only. Protocol 2026-07-28; 2025-11-25 and
2025-06-18 clients are answered on the same URL.
Auth: OAuth 2.1 with PKCE (S256), by dynamic client registration or a client ID
metadata document, discovered from the 401 challenge, so Claude and ChatGPT
connect with no key; or `Authorization: Bearer cp_live_…` with a key from
https://pagetovid.com/account
Docs: https://pagetovid.com/developers/mcp

Install in Claude Code:
claude mcp add --transport http pagetovid https://pagetovid.com/mcp

### Tools

- `create_video` (write, open-world) — [40 credits] [paid plans: + 40 per AI still unless ai_mode none; dry_run quotes] Turns a public web page into a narrated video: AI voiceover, motion graphics, optional subtitles. Asynchronous (minutes, sometimes past fifteen): returns a receipt with the video_id at once; get_video for the full status. A page behind a login is filmed only with a capture session from the VS Code or browser extension (Scale plan and up).
  Parameters: url*, goal, aspect_ratio, language, target_seconds, subtitles, tone, voice, music, brand_name, focus, idempotency_key, theme, intro, outro, routing, look, caption_style, caption_animation, caption_emphasis, grade, sfx_level, callout, cursor_style, press_effect, end_screen, edit_style, ai_mode, ai_budget, model, optimize, quality_gate, generate_motion, outputs, draft, callback_url, dry_run, max_credits, pronunciations
- `create_animation` (write) — [40 credits] From content you hold (figures, notes, story), no URL. You write scenes; each drawn, voiced, captioned (list_motions: 25 visuals, some with kinds; visual "rushie" = 664 designed cards, e.g. data {rushie:{template:"end-card",props:{headline,mark,url,cta}}}). AI clips (paid plans) only if asked: data.generate (+data.clip) per scene, or ai_mode rich (assist: stills), the server picks scenes, writes prompts; dry_run shows ai_plan.added. Returns a receipt; get_video for the full status.
  Parameters: scenes*, aspect_ratio, language, voice, music, tone, subtitles, intro, outro, target_seconds, title, brand_name, cta_text, source_url, theme, look, caption_style, caption_animation, caption_emphasis, grade, sfx_level, callout, cursor_style, press_effect, end_screen, edit_style, pronunciations, generate_motion, ai_mode, ai_budget, model, character, objects, idempotency_key, outputs, draft, callback_url, dry_run, max_credits
- `cancel_video` (write, destructive, idempotent) — [Free] Stops a running render and refunds its render credit and any AI visual still in flight; AI visuals already made stay (reused free). Use it when get_storyboard shows a plan you do not want. A finished render cannot be cancelled. The video is marked cancelled at once; the worker stops at its next step.
  Parameters: video_id*
- `get_video` (read-only, idempotent) — [Free] Reads this account. The full status of a render: phase and progress while it runs (with poll_after_seconds), then the files, length, credits, warnings and quality; on a free film, `upgrade` to relay once. `status` is one of, in pipeline order: draft, queued, analyzing, scripting, recording, voicing, rendering, held, done, error. In flight, so poll again after poll_after_seconds: queued, analyzing, scripting, recording, voicing, rendering. Terminal, so stop polling: held, done, error — a cancelled render ends as error with the reason in `error`, and a film can be done and still carry warnings. held: finished but unpublished by quality_gate. draft has not been queued.
  Parameters: video_id*
- `release_video` (write, idempotent) — [Free] Publishes a video its quality_gate held (status "held") as it is: status becomes done. Nothing is re-rendered.
  Parameters: video_id*
- `get_video_embed` (read-only, idempotent) — [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.
  Parameters: video_id*, page_url, title, description
- `list_models` (read-only, idempotent) — [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.
  Parameters: modality, include_unavailable
- `quote_cost` (read-only, idempotent) — [Free] What something will cost, spending nothing: one generation (kind clip or image, optional model, duration_s, resolution, role, count), or a video_id's next rerender_video (render plus every AI visual not yet made). A length between two a model makes is rounded UP, with a warning; one it cannot make is refused with what it can. plan_note says when this plan has no AI generation.
  Parameters: video_id, kind, model, duration_s, resolution, role, count
- `list_video_options` (read-only, idempotent) — [Free] Lists what create_video accepts: goals, aspect ratios, languages, voices, background music beds (9, each with a family: calm, energetic, serious, playful) and the allowed length range. Static reference data — no account access.
  Parameters: none
- `list_motions` (read-only, idempotent) — [Free] How a scene can look: 26 visuals, 817 animations, motions, transitions, fx. Check pairs before writing scenes. New: get_motion_grammar.
  Parameters: rushie, for_scene
- `list_themes` (read-only, idempotent) — [Free] Lists what the theme parameter accepts: the built-in presets, the modes, the type faces the renderer can load, and the contrast and palette rules enforced before a credit moves. Static reference data.
  Parameters: none
- `inspect_page` (read-only, idempotent, open-world) — [Free] Opens a public page in a real browser and ranks what a video could film — calls to action, images, cards, pricing, testimonials, search boxes, headings — each with a CSS selector, kind, size and score (a rank, not a percentage). Says when a robot check, sign-in or missing page stood in front of it (blocked, block_kind), and which fields will never be typed into.
  Parameters: url*, aspect_ratio, limit, kinds
- `detect_brand` (read-only, idempotent, open-world) — [Free] Reads a public page's design tokens from its live CSS: accent colours, heading typeface, light or dark ground, corner style. Returns a theme ready for create_video, create_animation or rerender_video, plus any site colour the film cannot paint with and why.
  Parameters: url*
- `get_account` (read-only, idempotent) — [Free] Reads this account. CALL THIS FIRST: plan, credits, whether AI visuals are available and charged, watermark, revisions, film passes, add-on clips, renders running, limits. Then: inspect_page (in the aspect you will film), create_video or create_animation, get_storyboard (the chosen shots), update_storyboard, rerender_video.
  Parameters: none
- `list_videos` (read-only, idempotent) — [Free] Reads this 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.
  Parameters: status, query, created_after, cursor, limit
- `get_storyboard` (read-only, idempotent) — [Free] Reads this 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).
  Parameters: video_id*
- `update_storyboard` (write) — [Free] Edits a video's storyboard in 22 operations, each described on its branch: words, captions, visuals (incl. "rushie" designed cards: data.rushie {template, props}), data, shots, scenes, transitions, fx, presenter, voice, music, look. Does not re-render — rerender_video makes the new film. Every call is snapshotted, so an edit can be undone (list_revisions).
  Parameters: video_id*, operations*
- `rerender_video` (write, destructive, open-world) — [40 credits] [free: captions_only once per paid render; a missed length target once] A new film from the video's current storyboard, without re-planning, plus any AI visual not yet made (quote_cost prices it). Free once per video when the film missed its length target (length_within_tolerance: false). The file is replaced when the new render finishes. Returns a start receipt; call get_video for the full status.
  Parameters: video_id*, theme, idempotency_key, captions_only, target_seconds, quality_gate, outputs, draft, callback_url, dry_run, max_credits
- `translate_video` (write, open-world) — [40 credits] per language: a NEW video from an existing one — same storyboard and pictures, narration translated, re-voiced and re-captioned, card text (rushie cards too) translated. Filmed scenes are re-recorded on the site's page in that language when it has one (hreflang), else the footage is reused and `scenes` says so. Charged and refunded like any render; AI visuals already made are reused free.
  Parameters: video_id*, languages*, idempotency_key
- `get_site_plan` (write, idempotent, open-world) — [Free] Up to 5 ranked videos a site should have, one per subject: goal, pitch, the real page it films (checked), the video made; detail full adds the brief, sources and shots. First call generates it (~10-20 s, no credit), then banks the site's images, videos and page clips in the background (media counts them). generate_site_videos works from it.
  Parameters: site_url*, language, refresh, limit, detail
- `generate_site_videos` (write, open-world) — [40 credits] Per video started. One filmed video per get_site_plan idea without one (or the idea_ids given), of its verified page with its sourced brief as focus. Without confirm it lists what it would make and the cost, capped at the balance (the rest under needs_credits), creating nothing; confirm=true starts those. get_video reports each. A retry never starts an idea twice.
  Parameters: site_url*, idea_ids, url, aspect_ratio, language, voice, music, subtitles, intro, outro, brand_name, theme, look, caption_style, confirm, max_videos
- `create_show` (write, open-world) — [Free] A show makes a video from each new item in a feed: a weekly release video from a changelog, a daily listing video from an RSS feed, a clip per new post. Episodes are ordinary videos 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.
  Parameters: site_url*, name*, kind, feed_kind, feed_url, source, watchlist, repeat_every, feed_map, cadence, max_episodes_per_run, max_credits_per_day, format_id, format_version, goal, aspect_ratio, language, target_seconds, tone, voice, music, subtitles, intro, outro, brand_name, theme, focus_template, title_template, scenes, routing
- `list_shows` (read-only, idempotent) — [Free] Reads this 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.
  Parameters: site_url
- `run_show` (write, open-world) — [40 credits] Per episode started. Reads the show's feed (or the items given), skips items already made, and — within max_episodes_per_run and max_credits_per_day — starts one video per new item. Without confirm: the list, nothing spent. 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.
  Parameters: show_id*, confirm, items
- `update_show` (write, idempotent) — [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.
  Parameters: show_id*, active, cadence, max_episodes_per_run, max_credits_per_day, name, format_id, format_version, format_version_latest, source, watchlist, repeat_every, rotate_webhook_secret
- `create_format` (write) — [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. Validated now against a sample item; nothing is rendered.
  Parameters: site_url*, name*, kind, goal, aspect_ratio, language, target_seconds, tone, voice, music, subtitles, intro, outro, brand_name, theme, focus_template, title_template, scenes, programme, routing
- `update_format` (write) — [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.
  Parameters: format_id*, name, note, goal, aspect_ratio, language, target_seconds, tone, voice, music, subtitles, intro, outro, brand_name, theme, focus_template, title_template, scenes, programme, routing
- `get_format` (read-only, idempotent) — [Free] The format's current template, its version history and the shows that run it, with each show's pin.
  Parameters: format_id*
- `list_formats` (read-only, idempotent) — [Free] The account's formats, newest change first, with versions and the shows running each.
  Parameters: site_url
- `fork_format` (write) — [Free] A new format whose version 1 is the original's latest version, unpinned from its parent. Edit the copy without touching the original.
  Parameters: format_id*, name, site_url
- `validate_format` (read-only, idempotent) — [Free] Compiles the template against a sample item, touching no database or 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.
  Parameters: name, kind, goal, aspect_ratio, language, target_seconds, tone, voice, music, subtitles, intro, outro, brand_name, theme, focus_template, title_template, scenes, programme, routing
- `preview_episode` (read-only, idempotent, open-world) — [Free] Runs the format's resolvers against the item (real calls, cached) and compiles the storyboard: every beat's final text, the beats dropped and why, the integrity report and where every bound value came from. Nothing is rendered. Read it before run_show confirm=true.
  Parameters: format_id*, format_version, item
- `verify_episode` (read-only, idempotent) — [Free] The proof behind a film: the format version that made it (template SHA-256), every resolver source and what it fetched, the integrity report, the claim ledger (which figures trace to the page, the brief or nothing), the Content Credentials (C2PA), and a check recompiling the stored data against the narration word for word.
  Parameters: episode_id, video_id
- `register_mcp_connection` (write, idempotent) — [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.
  Parameters: alias*, url*, kind, secret, note
- `create_character` (write, idempotent) — [Free or 40 credits] Names a character so generated clips that name it keep one identity. refs (1 to 3 image URLs on this account) is free; a generate prompt DRAWS the reference (paid plans, refunded on failure). Then an image scene's data.clip=true and data.character="<name>". From one of your films take raw_frame_url, never thumbnail_url: its burnt-in text teaches the generator to draw text.
  Parameters: name*, refs, generate, description, site_url
- `list_characters` (read-only, idempotent) — [Free] The reusable characters on this account, each with its reference images and description.
  Parameters: none
- `list_commons_assets` (read-only, idempotent) — [Free] Media people shared from their banks for anyone's films — logos, product shots, illustrations, recorded flows — with tags, a licence and the site to credit. An image scene takes an asset's id as data.asset_id (or its url as imageUrl); a gallery takes urls. Only assets their owners switched to shared.
  Parameters: kind, tag, q, limit
- `generate_asset` (write) — [40 or 311 credits] One AI still (40 credits each) or clip (house 311, a named model its list_models price) straight into your bank — no render. Clip controls are refused, with the allowed values, when the model is not sent them; model auto picks one and says why. best_of makes N and keeps the best graded (all N charged). Charged before, refunded on failure; dry_run quotes it free. Paid plans.
  Parameters: kind, prompt*, aspect_ratio, model, count, optimize, duration_s, resolution, first_frame, last_frame, seed, negative_prompt, camera, shot, best_of, dry_run, max_credits, character, objects, tags, site_url, idempotency_key
- `list_assets` (read-only, idempotent) — [Free] Your PRIVATE bank: every image, clip and audio file, by origin and subject, with id, URL, brief, tags and facets. Reuse a picture by putting its id in an image scene as data.asset_id (a clip resolves to clipUrl by itself); an audio asset is a film's music as "asset:<id>". Reusing costs no credit.
  Parameters: kind, q, character, site_url, limit
- `list_connections` (read-only, idempotent) — [Free] Every registered connection with its alias, kind and URL. Credentials are never returned.
  Parameters: none
- `create_object` (write, idempotent) — [Free] Names a product, logo, packaging, place, vehicle or UI screen from reference images so films keep it identical. Generated pictures take it in data.objects (clips, stills, insets, generate_asset) next to a character; image, gallery, pricing and compare cards draw it from data.object with its name and price.
  Parameters: name*, kind*, refs*, description, site_url, source_url, metadata
- `list_objects` (read-only, idempotent) — [Free] The reusable objects on this account, with reference images, kind and metadata (price, brand, sku).
  Parameters: kind, q, site_url
- `update_object` (write, idempotent) — [Free] Changes only the fields sent. Media already generated with it is kept until a scene's description changes.
  Parameters: name*, new_name, kind, refs, description, site_url, source_url, metadata
- `delete_object` (write, destructive, idempotent) — [Free] Deletes an object by name. Its images stay in your bank and media made with it stays in its films.
  Parameters: name*
- `import_objects` (write, idempotent, open-world) — [Free] Creates or replaces up to 50 objects from a product feed. Each image is downloaded (public addresses only) and banked as a reference. Failed rows are listed with the reason.
  Parameters: items*, site_url
- `save_scene` (write, idempotent) — [Free] Saves a scene for reuse: narration, visual, data, style AND its footage and generated media (a copy). Reusing it — update_storyboard add_scene_from_library, create_animation from_library — films and generates nothing, so no AI credit. Write {{placeholders}} in its narration or data first to fill them per use.
  Parameters: video_id*, scene_id*, name*, tags
- `list_scenes` (read-only, idempotent) — [Free] Saved scenes, newest first: name, id, visual, aspect, whether footage is kept, the {{placeholders}} each needs as params, and tags.
  Parameters: q, tags, site_url, limit
- `copy_scene` (write) — [Free] Copies a scene into another of your videos with its footage and generated media, so nothing is filmed or generated again. A recording cannot change aspect, nor go into a film made from data. Does not re-render.
  Parameters: from_video_id*, scene_id*, to_video_id*, after_scene_id
- `create_motion` (write) — [Paid plans] Designs a custom motion graphic from a brief (one text-model call; AI plans or a film pass; no credits charged), checks layout, legibility, contrast and timing, and saves it as a private template with params. Use it in a scene: visual "motion", data {motion:{specId, params}}.
  Parameters: brief*, name, language, site_url, tags
- `list_motion_templates` (read-only, idempotent) — [Free] Your saved motion graphics (visual "motion") and the commons, with their params. Rushie designed cards: list_motions {rushie}.
  Parameters: scope, q
- `get_motion_template` (read-only, idempotent) — [Free] One template with its full spec (layers, motion tokens, declared params).
  Parameters: template_id*
- `update_motion_template` (write, idempotent) — [Free] Renames, retags, sets param defaults or visibility, or replaces the spec of a template you wrote. Films already using it keep their picture.
  Parameters: template_id*, name, tags, defaults, visibility, spec
- `get_motion_grammar` (read-only, idempotent) — [Free] The grammar for writing your own animation as a motion spec: no topic → a short index and the authoring loop; topic → one rule file (layers, params, timing, motion, colour, layout, doctrine, examples, brief). Generated from the DSL itself.
  Parameters: topic
- `validate_motion_spec` (read-only, idempotent) — [Free] Dry-run a spec: deterministic repairs, schema, params, layout/legibility/contrast/timing on four frames and the motion doctrine. Returns ok, every problem with its path and fix, the repaired spec and the params schema. Nothing is saved.
  Parameters: spec*, params, site_url
- `preview_motion` (read-only, idempotent) — [Free] Frames back without a render: per aspect (16:9, 9:16, 1:1) a PNG sheet of four beats (entering, landed, hold, exit) — a deterministic LAYOUT wireframe from the DSL's geometry (exact boxes, wrapping, sizes, colours, timing; system font, no blur or shadow) — plus the problems measured on that frame.
  Parameters: spec, template_id, params, aspects, seconds, site_url
- `save_motion_spec` (write) — [Free] Saves a spec you wrote as a private template once it passes validate_motion_spec (repairs applied). Returns its id, params schema and the scene JSON that uses it: visual "motion", data {motion:{specId, params}}.
  Parameters: spec*, name, tags, params, site_url, visibility
- `upload_asset` (write, idempotent, open-world) — [Free] Puts a file in your bank from a public https url or small data_base64 (a bigger file you hold: create_upload). Picture or clip → data.asset_id in an image scene; audio → music "asset:<id>"; deck (PDF/PPTX) → every slide's text and pictures, to write the storyboard from. Identical bytes return the existing asset.
  Parameters: url, data_base64, filename, kind, name, site_url
- `create_upload` (write) — [Free] A one-hour address to send a file you hold (picture, clip, music, font, PDF/PPTX deck, ≤ 30 MB): curl -sS -T <file> "<upload_url>". The reply is the asset or the deck's slides.
  Parameters: kind, name, site_url
- `list_voices` (read-only, idempotent) — [Free] The narrator voices with measured pitch (band and median Hz) and a short sample in the chosen language where one exists (else sample_url is null). Every voice speaks every language.
  Parameters: language, pitch
- `get_timeline` (read-only, idempotent) — [Free] Each scene's start and end in the finished MP4 (seconds), what drew it (recording, page still, AI clip/still, footage, graphic, card, inset), its transition, its slice of the one voice track with word onsets, plus the music and caption style. timeline_source: stored by the render, or rebuilt from the scenes.
  Parameters: video_id*
- `get_frames` (read-only, idempotent) — [Free] JPEG stills (≤ 1280 px wide) cut from the finished MP4 at 1–6 moments in seconds, as URLs. Cached per render.
  Parameters: video_id*, times*
- `set_brand_kit` (write, idempotent, open-world) — [Free] Partial update of a site's brand kit: logo, palette, face (named or an uploaded font), intro/outro templates, watermark and logo corner, default voice/music/captions/look/transition. null clears a field. Films of the site inherit it unless the call overrides.
  Parameters: site_url*, from_detect, colors, logo_asset_id, font_asset_id, logo_corner, logo_safe_zone, watermark, voice, music, look, caption_style, transition, end_screen, intro, font_family, model
- `get_brand_kit` (read-only, idempotent) — [Free] A site's brand kit, what a film paints from it (and what it cannot, with why), the effective watermark, and the account defaults beneath it.
  Parameters: site_url*
- `set_account_defaults` (write, idempotent) — [Free] Partial update of the options every film starts from (below a site's brand kit). null clears a field.
  Parameters: voice, music, look, caption_style, transition, end_screen, intro, font_family, model
- `list_options` (read-only, idempotent) — [Free] Every enum and range a film accepts (voices, languages, beds, looks, captions, motions, transitions, visuals, aspects, faces, brand kit), the models with a credit example, and the inheritance levels.
  Parameters: none
- `invite_member` (write, open-world) — [Free] Emails an invite to this workspace with a role, optional site limits and monthly credit cap. Members spend the owner's credits. Seats incl. owner: Free/Creator 1, Pro 3, Scale 5, Business 15, Agency unlimited.
  Parameters: email*, role*, site_urls, credit_cap
- `list_members` (read-only, idempotent) — [Free] Members with role, sites, cap and spend this month; seats; your workspaces (send one as the X-PageToVid-Workspace header to act in it).
  Parameters: site_url
- `update_member` (write, idempotent) — [Free] Changes only the fields sent. Only the owner grants or changes admin and billing.
  Parameters: member_id*, role, site_urls, credit_cap
- `remove_member` (write, destructive, idempotent) — [Free] Removes a member or cancels an invite, freeing the seat; your own member id leaves the workspace. Their work stays.
  Parameters: member_id*
- `create_review_link` (write) — [Free] A link to watch the film and, if allowed, comment with no account. Shown once; only its hash is stored.
  Parameters: video_id*, expires_in_hours, can_comment
- `request_approval` (write) — [Free] Opens an approval round for the named approvers; supersedes a pending one.
  Parameters: video_id*, approver_ids*
- `approve` (write) — [Free] Approves the pending round, as one of its approvers.
  Parameters: video_id*, comment
- `request_changes` (write) — [Free] Closes the pending round as changes requested.
  Parameters: video_id*, comment*
- `list_comments` (read-only, idempotent) — [Free] Timestamped comments from members and review-link guests, oldest first, and the approval round.
  Parameters: video_id*
- `add_comment` (write) — [Free] Adds a timestamped comment; open comments feed the editor's AI revision.
  Parameters: video_id*, scene_id, at_s, text*
- `get_audit_log` (read-only, idempotent) — [Free] Who did what here, newest first: members, spending, review links, approvals, comments.
  Parameters: site_url, since
- `set_webhook` (write, idempotent) — [Free] Sets (or with null clears) the account-wide URL that receives a signed JSON event whenever a render ends. The first time a secret is needed it is created and returned here, once.
  Parameters: url*
- `rotate_webhook_secret` (write, destructive) — [Free] Replaces the secret completion events are signed with and returns the new one, once. The old secret stops verifying at once, including for retries still in flight.
  Parameters: none
- `list_revisions` (read-only, idempotent) — [Free] Every storyboard edit, newest first: what changed and a revision_id. restore_revision puts the storyboard back as it was before one.
  Parameters: video_id*, limit
- `restore_revision` (write, destructive) — [Free] Puts the storyboard back as it was before a revision, undoing that edit and every later one. Itself a revision, so it can be undone. Nothing is re-rendered until rerender_video.
  Parameters: video_id*, revision_id*
- `update_character` (write, idempotent) — [Free] Changes a character's references, description or name; anything not given is kept. Clips already made keep the look they were made with.
  Parameters: name*, new_name, refs, description
- `delete_character` (write, destructive, idempotent) — [Free] Deletes a character by name. Its reference images stay in your bank and clips made with it stay in their films.
  Parameters: name*

### For the best screencast

- Call inspect_page in the aspect ratio you will film. 9:16 films the page's
  own MOBILE layout (414×736 phone viewport, iPhone user agent); 16:9 and 1:1
  film the 1280-wide desktop layout. Nothing is squeezed from one into the other.
- Prefer a page whose ranked subjects are the product — a listing, a search
  box, cards, a table — over a marketing hero.
- Put facts and any offer in focus; a line to be said word for word goes in
  quotation marks and is placed verbatim.
- After the first render, get_storyboard shows each scene's captured_url (where
  the camera really was) and the provenance of every claim (page, brief, or
  nowhere). update_storyboard's set_shot points a scene at a specific element —
  a selector from inspect_page with a click, typing, a hover or a spotlight,
  checked on the live page before the edit is accepted — and rerender_video
  films it again.
- get_site_plan returns up to 5 ranked video ideas for a whole site in about
  10–20 seconds; the site's images and videos, and short clips of key moments on
  its top pages, are then banked in the background for its films.
  generate_site_videos makes the missing ones (a free preview without confirm). create_show turns a
  feed into a recurring video, held until its owner confirms the first run and
  capped in credits per day. Its items may also come from a query on a
  registered connection or from a watchlist, once per month, quarter or year.
- A show runs a FORMAT, versioned: create_format / update_format (a new
  version each time; shows pin one or follow latest), validate_format for free.
  An animation format may carry a programme — beats, resolvers that fetch data
  from a connection (register_mcp_connection), computed values, and an
  integrity gate that refuses any figure not bound to an expression.
  preview_episode compiles a real episode for free; verify_episode returns the
  proof behind one — format version, sources, integrity report, Content
  Credentials. Every public video of a domain is also an RSS feed at
  https://pagetovid.com/videos/<domain>/feed.xml.

## REST API

Base: https://pagetovid.com
- `POST /api/v1/videos` — start a render from a page URL (Pro plan and up; a
  storyboard you write yourself goes through the MCP tool create_animation). Returns 202 with an id and statusUrl.
  Optional: outputs (1-4 shapes from one storyboard, an id each), qualityGate
  ({minScore, onFail: auto_fix | hold | deliver}), callbackUrl (a signed POST
  when the render ends), pronunciations ([{text, say}]), aiMode (none | assist),
  draft (a free watermarked preview).
- `GET /api/v1/videos/:id` — status (held: finished, not published by the
  gate), progress, score, the gate's verdict, the other shapes, and when done
  the video, poster, subtitle URLs plus ready-to-paste Open Graph video tags.
- `GET|POST /api/v1/sites/:domain/plan` — the plan for a whole site (POST generates it, free).
- `GET|POST /api/v1/sites/:domain/plan/videos` — the set of videos the plan asks for;
  POST previews, POST with confirm: true starts them (40 credits each).
- `GET|POST /api/v1/sites/:domain/shows` — a site's shows; POST creates one (held).
- `POST /api/v1/shows/:id/run` (confirm) · `PATCH /api/v1/shows/:id` (pause, resume, caps).
Auth: the same `cp_live_` bearer key. Docs: https://pagetovid.com/developers

## Options

Goals: explainer, ad, demo, tutorial, article
Aspect ratios: 16:9, 9:16, 1:1, 4:5
Languages (verified end to end): en (English), fr (Français), es (Español), de (Deutsch), it (Italiano), pt (Português), nl (Nederlands), ar (العربية), hi (हिन्दी), ko (한국어), pl (Polski), tr (Türkçe), sv (Svenska)
Length: 15–180 seconds, default 45
Rate limit: 10 renders per minute per account
Credits: 40 per finished video; an AI image 40, the house AI clip (Veo 3.1 Fast, 8 s) 311, a clip from a named model priced per second from its real cost — list_models and quote_cost (both free) show any price first. A render that fails for a system reason is refunded in full

## Pages

- https://pagetovid.com/ — what it does, with a demo made by the product itself
- https://pagetovid.com/pricing — plans, pay-per-film prices and credits
- https://pagetovid.com/features — every capability, with the numbers behind it
- https://pagetovid.com/features/ai-clips — generated video clips and B-roll in a website film, the models and their credit prices
- https://pagetovid.com/features/ai-characters — one character, the same face in every generated clip
- https://pagetovid.com/features/presenter — a generated presenter in the corner, over the real screencast
- https://pagetovid.com/videos — public films made with PageToVid, by website
- https://pagetovid.com/claude-video-generator — make videos from Claude through the MCP connector
- https://pagetovid.com/chatgpt-video-generator — make videos from ChatGPT
- https://pagetovid.com/assistants — make and edit videos from Claude, ChatGPT, Claude Code, Cursor, VS Code, Codex, Gemini CLI or any MCP client: setup steps for each
- https://pagetovid.com/developers — REST API
- https://pagetovid.com/developers/mcp — MCP server, install snippets per client, tool reference
- https://pagetovid.com/animations — the scene animations videos are composed from
- https://pagetovid.com/use-cases — who uses it and why
- https://pagetovid.com/compare — PageToVid compared with other AI video tools, with sources
- https://pagetovid.com/resources — guides and a video glossary
- https://pagetovid.com/extension — the two free extensions (Chrome and VS Code)
- https://pagetovid.com/extension/chrome — PageToVid — Capture for Chrome: screencasts, full-page shots, elements, brand kits and pages behind a login, into the media bank (Chrome Web Store)
- https://pagetovid.com/extension/vscode — PageToVid Studio for VS Code (also Cursor, Windsurf, VSCodium): connects a project to Claude Code with slash commands for videos, shows and formats (VS Code Marketplace)
- https://pagetovid.com/terms · https://pagetovid.com/privacy
- Pages are also published in French (https://pagetovid.com/fr), Spanish (https://pagetovid.com/es) and German (https://pagetovid.com/de).

## Use cases

- [Demo videos of your real app, for every release](https://pagetovid.com/use-cases/saas-demo-video): Make a SaaS demo video from your URL: your real app filmed in a browser, AI script, voice-over and captions in minutes. 3 free films per site, no card.
- [Turn product pages into scroll-stopping video ads](https://pagetovid.com/use-cases/ecommerce-video-ads): Make ecommerce video ads from a product URL: AI voice-over, captions and animated price in 9:16 for TikTok, Reels, Shorts. 3 free films per site, no card.
- [Turn articles into faceless videos](https://pagetovid.com/use-cases/article-to-video): Turn a blog post or newsletter into a narrated faceless video: a documentary-style script, the article's own images, captions. 3 free films per site.
- [Client videos from a URL, delivered under your name](https://pagetovid.com/use-cases/agency-video-production): Agencies: turn each client's website into branded demo, social and multilingual videos, with review links, team seats and an API. 3 free films per site.
- [Turn docs and wikis into onboarding videos](https://pagetovid.com/use-cases/onboarding-training-videos): Turn a handbook, wiki or help page into a narrated training video with captions in 13 languages. Re-render when it changes. 3 free films per site.
- [Turn help articles into how-to videos](https://pagetovid.com/use-cases/support-help-videos): Turn help-center articles into narrated how-to videos of your real product, one scene per step, captioned. Re-render on release. 3 free films per site.
- [Turn every how-to into a video that stays true](https://pagetovid.com/use-cases/tutorial-videos): Make step-by-step tutorial videos of your real product: clicks, typed queries and spotlit controls, narrated and captioned. 3 free films per site, no card.
- [Turn a landing page into an ad that earns the click](https://pagetovid.com/use-cases/video-ads): Turn the page your ad links to into a short video ad: a hook first, real footage of the page, captions and one call to action. 3 free films per site.
- [Make vertical videos that look native, not repurposed](https://pagetovid.com/use-cases/tiktok-videos): Make 9:16 videos for TikTok, Reels and Shorts from any page: your real mobile layout in a phone viewport, word-synced captions. 3 free films per site.
- [Turn any website into a narrated video](https://pagetovid.com/use-cases/website-to-video): Turn any website URL into a narrated video: AI script, a real screencast of the live page, voice-over in 13 languages, captions. 3 free films per site.
- [An explainer video made from your own website](https://pagetovid.com/use-cases/explainer-video-maker): Make an explainer video from your website: a script built on the problem you solve, real product footage, voice-over and captions. 3 free films per site.
- [Turn every release note into a short video](https://pagetovid.com/use-cases/release-notes-video): Turn a changelog entry into a short narrated video of the new feature in your real product, or automate one per release. 3 free films per site.
- [Turn property listings into narrated videos](https://pagetovid.com/use-cases/real-estate-listing-video): Turn a listing page into a narrated property video: real photos, price, key facts, captions, in 9:16 for Reels and 16:9 for portals. 3 free films per site.
- [Translate a video into 13 languages](https://pagetovid.com/use-cases/video-translation): Translate a website video into up to 13 languages: narration translated and re-voiced, captions and on-screen text redone, figures localised.
- [Turn the app you vibe-coded into a video](https://pagetovid.com/use-cases/vibe-coded-app-video): Turn the app you built with Lovable, Bolt, v0, Replit or AI Studio into a narrated video of the real product. Paste the live URL. 3 free films per site.
- [Make your app launch video from its URL](https://pagetovid.com/use-cases/app-launch-video): Make a launch video from your app's URL: the real product filmed, narrated, captioned, in 16:9 and 9:16 for Product Hunt and TikTok. 3 free films per site.
- [Turn a website into a video for free](https://pagetovid.com/use-cases/free-website-to-video): Turn a website into a narrated video for free: 3 free films per website, no card, filmed on your real site. What is free, what is not, and how to start.

## Comparisons

- [PageToVid vs Pictory](https://pagetovid.com/compare/pictory): Pictory turns an article into a stock-footage video; PageToVid films the real website in a browser. Features, free plans and prices compared, with sources.
- [PageToVid vs Synthesia](https://pagetovid.com/compare/synthesia): Synthesia makes AI-avatar presenter videos; PageToVid films your real website in a browser. Who each is for, features, free plans and prices, with sources.
- [PageToVid vs HeyGen](https://pagetovid.com/compare/heygen): HeyGen makes realistic avatar videos and translations; PageToVid films your real website in a browser. Features, MCP access, free plans and prices, sourced.
- [PageToVid vs InVideo](https://pagetovid.com/compare/invideo): InVideo AI is an agentic editor with generative models and stock; PageToVid films your real website in a browser. Features, MCP, free plans and prices, sourced.
- [PageToVid vs Lumen5](https://pagetovid.com/compare/lumen5): Lumen5 turns blogs and documents into branded stock-media videos; PageToVid films your real website in a browser. Features, free plans and prices, sourced.
- [PageToVid vs Fliki](https://pagetovid.com/compare/fliki): Fliki pairs a huge AI voice library with stock and AI visuals; PageToVid films your real website in a browser. Features, free plans and prices, with sources.
- [PageToVid vs Loom](https://pagetovid.com/compare/loom): Loom records your screen and camera for async messages; PageToVid films a website automatically and narrates it with AI. Features, free plans, prices, sourced.
- [PageToVid vs Steve AI](https://pagetovid.com/compare/steve-ai): Steve AI makes animated, live-action and generative videos from text and blogs; PageToVid films your real website in a browser. Features and plans, sourced.
- [PageToVid vs Revid](https://pagetovid.com/compare/revid): Revid makes short-form social videos from links, prompts and articles; PageToVid films your real website in a browser. Features, MCP, plans and prices, sourced.

## Optional

- https://pagetovid.com/llms-full.txt — this file plus the full text of the use cases, the comparisons and the product guides