Read & review
Let an AI agent look at and read a video before or after it edits it — one frame as an image, what is said, what is on the timeline, and what a web recording clicked.
Recording, styling and effects let an agent make a video. screenify read lets it look at one — so it can check
its own work before handing it to you, instead of guessing.
screenify read --list --json # what can be read, and each reader's options
screenify read frame --project ~/Desktop/demo.mp4 --at 8 --json # one frame of a video you exported
screenify read transcript --project demo.screenify --json # what is said, with times
screenify read timeline --project demo.screenify --json # what is on the timeline, second by second
screenify read events --project demo.screenify --json # what a web recording clicked, typed and visitedAI apps without a terminal (Claude Desktop, Cursor, …) get the same thing through one tool of the
MCP server: read_project, with kind set to frame, transcript, timeline or events.
What it can read
| Reader | Answers | Main options |
|---|---|---|
frame | "What does the video look like at second X?" — one rendered frame as an image | at (required) · out (save a full-resolution PNG/JPG) · max (size of the preview image, default 1568 px) |
transcript | "What is said, and when?" — your captions and the scripts of AI voiceover passages | from · to · words=true (word-level timing) |
timeline | "What is on the timeline at second X?" — every clip, zoom, 3D move, title, graphic, music and voiceover segment, each with a short label | from · to · tracks=zoom,text |
events | "What did the browser do?" — clicks, typing, scrolls and pages visited in a web demo | from · to |
Pass options with --arg key=value (repeatable). --at and --out are shortcuts for the two most common ones.
Look at the video you just exported
frame reads either a .screenify project or an exported video file. When an agent has just exported a video with
styling flags — a 3D device, an environment, a wallpaper — read the exported file: those flags apply to that export
only and are not saved back into the project, so the project alone would not show them.
screenify read frame --project ~/Desktop/launch.mp4 --at 12 --json # a preview image, sized for AI vision
screenify read frame --project launch.screenify --at 3 --out ~/Desktop/a.png --json # full resolution, from the projectReading a project renders the frame with the project's own settings — exactly what a plain screenify export of it
would show. A recording that was never styled gets a random wallpaper when exported, so for those the result carries a
warning to read the exported file instead.
Times are timeline seconds
Every time you pass in and every time you get back is a second of the finished video — after cuts, speed changes and intro or outro spaces. A web recording's clicks are mapped the same way, so an agent can put a title exactly on the moment something was clicked. A click that happened in a part that was cut is still listed, marked as not in the video.
"Not available" is an answer
Every read returns either the data or a short explanation of why there is nothing to read and what to do next:
{ "available": false, "kind": "transcript",
"reason": "No captions and no AI-voiceover script in this project",
"action": "Open the project in Screenify Studio → Captions → Generate (or add an AI voiceover from a script), then read again." }That is a normal result, not an error. transcript reads the captions and scripts already in the project — it does not
transcribe audio by itself, so a recording with speech but no captions needs Captions → Generate in the app first.
Review before you share
review checks a finished demo against rules you can measure, and returns {pass, failures, warnings} plus a contact
sheet — one image with a frame every few seconds and the middle of every title and graphic.
screenify read review --project ~/Desktop/demo.mp4 --json| It flags | |
|---|---|
| A blank or still-loading page in the recording | failure from 2 seconds, warning if shorter |
| Nothing moving for more than 4 seconds | warning |
| A 3D MacBook with nothing under it, or an environment that doesn't suit a software demo | warning — failure when both |
| A 3D MacBook that turns flat because no camera shot covers part of the recording | warning |
| Graphics still showing the template's sample numbers or names | failure |
| No clear opening or ending | warning |
| No background music, or music that stops abruptly | warning |
| A web demo that only scrolls, with no click or typing | warning |
| Two titles or graphics on screen at once | warning |
| Over 60 fps · larger than 1920 px | failure · warning |
It also lists the pages the recording visited, so you can check none of them shows anything private. Pass the
exported video to review exactly what you will share — the command line remembers which project and settings each
export came from. demo build runs this for every file it makes. Through MCP it is
read_project with kind: "review".
Reading never changes anything
Readers only read. Your project, its settings and its media stay exactly as they were — reading a frame renders from a private copy, never from the project itself.
Things worth asking for
- "Look at the video you just exported — anything that looks off before I post it?"
- "What does the narrator say between 20 and 40 seconds?"
- "Which zooms are already in this project?"
- "Add a title 'See pricing' right when I clicked Pricing in my web demo."
- "Save a full-resolution still of second 3 to my Desktop."
Build a whole demo
Describe a whole demo video in one storyboard file — the site to record, the 3D device, camera moves, graphics, narration and music — and build it with one command that also checks the result.
For agents & CI
screenify is built to be driven — by an AI agent like Claude Code, by your own scripts, or by a CI pipeline. Every command speaks JSON and the tool describes itself at runtime.