Command Line (Agent CLI)

screenify is a headless command-line tool that lets AI agents, CI pipelines, and scripts — or you — record and export with Screenify Studio without ever opening the app window. Every command speaks JSON, so anything that can run a shell command can drive it.

Unlike a plain screen recorder, screenify produces the same studio-quality output you get in the app — wallpapers, padding, rounded corners, camera overlays, device frames, 3D, watermarks, and music — all from command-line flags.

Install

The CLI ships inside Screenify Studio, so it always stays in sync with your app.

1. Open Screenify Studio → Settings → Command Line.
2. Click Enable for Agents & CLI.
3. Open a new terminal and run screenify.

That links a screenify command into your shell. Don't have the app yet? Download Screenify Studio first.

The command lives in the app bundle, so keep Screenify Studio installed (ideally in your Applications folder) and the CLI updates automatically with every release.

The output convention

• Pass --json to any command for machine-readable JSON on stdout.
• Long-running commands (like export) stream newline-delimited JSON (one event per line) so you can follow progress live.
• stdout stays clean — only the JSON events (with --json) or the human-readable result. Errors print to stderr.
• Exit code 0 means success; non-zero means failure.
• Internal diagnostics are silenced by default for clean output; set SCREENIFY_VERBOSE=1 to surface them when debugging.

Agents can discover the full, always-current contract at runtime:

screenify guide --json    # capability + schema manifest, self-describing

Quick start

# 1. Check permissions and capture readiness
screenify doctor --json

# 2. Discover what you can capture
screenify targets --json          # screens, windows, cameras, microphones

# 3. Record a screen and export it in one step
screenify record start --screen 1 --duration 5 --export demo.mp4 --json

# 4. Or style an existing recording into a polished video
screenify export demo.screenify -o pretty.mp4 \
  --wallpaper orange --padding 80 --watermark --aspect wide

Commands

Run screenify <command> --help for the full flag list of any command.

Recording

# Start, then stop later (background recording)
screenify record start --screen 1 --detach --json   # -> { "type": "started", "recordingId", "path" }
screenify record stop --json                          # -> { "type": "stopped", "path" }

# Or record for a fixed duration and export in one shot
screenify record start --screen 1 --duration 8 --export out.mp4 --json

Useful options: --screen <id>, --window <id>, --area "x,y,w,h" (capture a region), --system-audio, --duration <seconds>, --detach, --export <path>.

Studio-quality exports

This is what sets screenify apart from a raw recorder. Any export can be styled straight from flags:

For full control over any setting, use --set <path>=<value> (repeatable) or merge a config file with --config <file.json>. Discover every settable field with:

screenify config schema --json

Example — turn a plain recording into a vertical, branded clip:

screenify export demo.screenify -o reel.mp4 \
  --aspect vertical --wallpaper mist --padding 60 \
  --rounding 24 --watermark "Made with Screenify" --music on

By default, exports keep the recording's native resolution and frame rate, and your original project is never modified — the styling is applied to a temporary copy unless you opt to save it.

Working with AI agents

The point of screenify is that you don't have to type these commands — you ask an AI agent (like Claude Code) in plain language, and it runs them for you. Recording and producing a polished video becomes a one-sentence request.

How it works

1. Install screenify once — Settings → Command Line → Enable for Agents & CLI.
2. Use any AI agent that can run terminal commands (Claude Code, other coding agents, or your own scripts).
3. Ask in plain language. screenify is self-describing: the agent reads screenify guide --json and screenify <command> --help, picks the right options, and runs them. You get a finished video back.

Because the agent does the translating, you ask in your own words, in any language — never in flags.

Things you can ask for

• "Record a 10-second demo of my screen and save it as demo.mp4."
• "Capture a bug repro of the Safari window for 8 seconds, then export it."
• "Take my latest recording and make it look polished — orange wallpaper, padding, and a watermark."
• "Turn that recording into a vertical clip for TikTok with background music."
• "Make a square version of my last recording for Instagram, on a dark background."
• "Wrap this iPhone recording in a device frame and export it."

What the agent actually does

You say:

Record a 12-second demo of my screen and export it with a wallpaper and watermark.

Your agent runs, behind the scenes:

screenify doctor --json                              # confirm it can record
screenify record start --screen 1 --duration 12 --json
# -> reads the new project path from the JSON, e.g. "…/Recording-2026-06-11.screenify"

screenify export "…/Recording-2026-06-11.screenify" -o demo.mp4 \
  --wallpaper orange --padding 80 --watermark        # the studio styling

…and hands you demo.mp4. You never saw a flag.

Why agents work well with it

• Machine-readable — every command returns JSON, so the agent can read results (like the new recording's path) and chain the next step reliably.
• Self-describing — screenify guide --json is the single source of truth for what's available, so agents always have the current, accurate contract.
• Predictable — exit codes and streamed progress events let an agent know exactly when a step succeeded or failed.

Tip: if your agent isn't sure what's available, ask it to run screenify guide --json or screenify --help first — that's all it needs to learn every command and option.

Beyond agents — CI and scripts

The same properties make screenify ideal for automation without an agent: capture a UI demo as a build artifact in CI, generate a library of styled recordings from a script, or attach a fresh repro video to every bug report — all headless, all machine-readable.

For Claude Code users

Screenify ships a small skill that teaches Claude Code to reach for screenify on its own — so a request like "record a repro of this bug" just works, without you naming the tool or remembering any commands.

Automatic install

When you click Enable for Agents & CLI in Screenify Studio, the app installs the skill to ~/.claude/skills/screenify automatically (when Claude Code is detected on your machine). There's nothing else to do — start a new Claude Code session and it's ready. Uninstalling the command removes the skill again.

Manual install

To install it yourself, or to place it in a specific project, copy it from the app bundle:

mkdir -p ~/.claude/skills
cp -r "/Applications/Screenify Studio.app/Contents/Resources/screenify-skill" \
  ~/.claude/skills/screenify

If you keep the app somewhere other than your Applications folder, adjust the path. To scope the skill to a single project instead of your whole machine, copy it into that project's .claude/skills/screenify folder.

Verify it's working

Start a fresh Claude Code session and ask:

Record a 5-second demo of my screen and save it as demo.mp4.

Claude should pick up the skill and run screenify for you. If it doesn't, confirm screenify doctor --json runs in your terminal first (the command must be on your PATH).

The skill is intentionally thin — it points Claude at screenify guide --json for the authoritative, always-current contract, so it never drifts from the version of Screenify you have installed.

Other AI agents (Codex, Cursor, and more)

The skill above is just Claude Code's way of making screenify proactive — the CLI itself is agent-agnostic. Any tool that can run a shell command works out of the box, including Codex, Cursor, Windsurf, Gemini CLI, Aider, OpenCode, or your own scripts. There's nothing extra to install beyond the screenify command (Settings → Command Line → Enable for Agents & CLI).

Zero setup — just ask

Every agent learns the commands the same way: by running screenify --help and screenify guide --json (the self-describing manifest). Ask in plain language and name the tool once:

Use the screenify CLI to record a 5-second demo of my screen and export it.

Make it automatic (optional)

To have an agent reach for screenify on its own — without you naming it each time — add a short instruction to the file that agent reads for guidance. Paste this line:

To record the screen or produce a video, use the screenify command-line tool. Run screenify guide --json to discover its commands and options.

Where that line goes depends on the agent:

Once that line is in place, a request like "record a repro of this bug" uses screenify automatically — exactly like the Claude Code skill does.

Permissions

The first time you record, macOS asks for Screen Recording permission for Screenify Studio. Grant it in System Settings → Privacy & Security → Screen Recording, then run your command again. screenify doctor always reports the current permission state so an agent can check before recording.