Record & export

This is the foundation of the screenify CLI: capture a screen or window, then turn it into a polished video — no app window required. (To turn a website into a demo instead, see Web demos.)

Record

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

# Or start in the background and stop later
screenify record start --screen 1 --detach --json   # -> { "type": "started", "recordingId", "path" }
screenify record stop --json                          # -> { "type": "stopped", "path" }

Use screenify targets --json first to list the screens, windows, cameras, and microphones you can capture — the id it returns feeds straight into record.

Useful options:

Each recording is saved as a .screenify project in your library, which you can re-export with different styling any time.

Export & style

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

# 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

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

A path the config doesn't actually have is rejected with an error rather than quietly written, so a typo can never leave you with a normal-looking video that silently dropped your setting. When a field is part of a larger object, pass the whole object — setting one field of an object that doesn't exist yet would leave the rest missing:

screenify export demo.screenify -o out.mp4 \
  --set background.insetConfig='{"size":14,"color":[255,255,255],"opacity":30,"balanceX":0,"balanceY":0,"liquid":true}'

Browser frame

Recording a browser window puts your tabs, bookmarks bar, extensions and real URL into the video. Instead, record just the page and let Screenify draw a clean browser window around it — with an address bar you write yourself:

screenify export demo.screenify -o demo.mp4 \
  --browser chrome-light --url "screenify.studio/pricing" --tab "Pricing"

The frame is drawn, not photographed, so it stays crisp at any size and follows zoom and 3D camera moves with the recording. Corner rounding, shadow and inset apply to the window, so the result reads as one object rather than a page floating in front of a bar.

Photo mockups and device stages

Scenes you compose in the app — a photo mockup (your recording warped into the screen of a real photograph) or a multi-device stage — are stored in the project, so exporting it from the command line renders the same scene:

screenify export demo.screenify -o demo.mp4

The photo has to be in the local cache first. Pick it once in the app so it downloads, then the CLI can render it on any later export. If it's missing, the export still succeeds — it just comes out without the mockup, and says so on stderr.

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 pass --save.

A recording you haven't styled exports with a random wallpaper and a watermark by default (the same look the app gives a new recording), so a one-step record … --export out.mp4 already looks polished. Choose your own with --wallpaper <id> / --background <#hex>, or get a plain frame with --no-background --no-watermark.

Output formats

Set --format, or just let the output's extension decide (-o demo.gif makes a GIF):

Platform presets

--platform is a one-word shortcut that sets the right aspect ratio for where the video is going:

screenify export demo.screenify -o tiktok.mp4 --platform tiktok --wallpaper orange

An explicit --aspect always overrides --platform.

iOS Simulator demos

Record a booted iOS Simulator straight from the terminal. You get a clean, full-screen capture — no surrounding window chrome — saved as a portrait .screenify project you can frame and style like any other recording.

# List booted simulators, then record one
screenify targets simulators --json            # -> [{ "udid", "name", "runtime" }]
screenify record start --simulator --duration 8 --json   # auto-picks the only booted device

# Frame it in a photoreal device mockup on export
screenify export demo.screenify -o demo.mp4 \
  --device iphone-17-pro-max --device-color cosmic-orange

A simulator recording automatically zooms into each tap so the demo feels guided (turn it off with --no-auto-zoom), and the watermark and styling adapt to the vertical frame. Pass --simulator <udid> when more than one device is booted.

Device frames are part of Screenify Studio. If a frame doesn't appear on export, open that device and color once in the app to fetch it, then re-run the export.

Script the taps

You don't have to touch the simulator by hand — hand screenify a list of taps and it performs them while recording, then builds the zoom from them. Perfect for automated, repeatable demos and AI agents:

# taps.json: [ { "tap": [0.5, 0.28] }, { "wait": 2000 }, { "tap": [0.3, 0.55] }, { "swipe": { "from": [0.5, 0.8], "to": [0.5, 0.3] } } ]
screenify record start --simulator --actions taps.json --path demo.screenify --json
screenify export demo.screenify -o demo.mp4 --device iphone-17-pro-max

Tap and swipe coordinates are fractions of the device screen (0–1, top-left origin). Keep the simulator window visible, and grant the terminal Accessibility permission (System Settings → Privacy & Security → Accessibility) so it can drive the taps.

Next

That's recording your own screen or an iOS Simulator. To turn a website into a finished demo automatically, see Web demos.