llms.txt
Compare with other sites' llms.txt files →# Screen Now
> The free screen recorder in your browser: record your screen, camera and microphone with live captions, edit on a timeline (layouts, zooms, captions, titles, music), and export an MP4. No installation or account. Videos never leave the browser.
Screen Now runs at https://screen.now, entirely in the browser: recording, editing and exporting all happen on the person's computer, and their videos stay in that browser's storage. Desktop Chrome and Edge do everything; Safari and Firefox record and edit, without tab or system sound and without live captions; phones can't capture a screen, but their camera works.
Every edit is an operation on one document, the same ones the app's own buttons send, so an agent can do anything a person can do to a video, precisely, in one step, and undoably.
## Connect
- **In the page:** `window.screenNow`, for any agent that can run JavaScript in the screen.now tab (Claude in Chrome, Playwright, computer-use agents with a script tool).
- **WebMCP:** in browsers with `document.modelContext`, the same API as tools (below).
get() and apply() work on the video open in the editor; the rest of Your videos is a call away.
```js
await screenNow.videos(); // Your videos: id, name, length, scenes, which is open
await screenNow.newVideo('Launch'); // a new one, opened (kept once something is in it) → { ok, id }
await screenNow.openVideo(id); await screenNow.closeVideo();
await screenNow.renameVideo(id, 'Launch day'); await screenNow.duplicateVideo(id); // → the copy's id
await screenNow.deleteVideo(id); // ask the person first: undoable for 8 s
screenNow.get(); // the video: clips, transcript, recordings, settings (timeline seconds)
screenNow.help(); // { notes, ops }: how edits work, and every op with an example
screenNow.apply([...ops]); // atomic, one undo step → { ok, error?, created? }
screenNow.undo();
await screenNow.importFiles([file]); // a File, as a person imports it → what each became
await screenNow.frame(4.2); // the finished picture at 4.2 s, as a JPEG data URL
screenNow.seek(4.2); screenNow.play(); screenNow.pause();
await screenNow.exportVideo(); // makes the MP4 at the output settings → { ok, error? }; it then waits in the export sheet, and its Download video button saves it
```
### WebMCP tools
- `list_videos`: List Your videos: each one’s id, name, length, scenes, when made and last edited, whether it is the sample, and which is open in the editor (the one the other tools work on).
- `open_video`: Open one of Your videos in the editor, by its id (from list_videos).
- `new_video`: Start a new, empty video and open it, optionally named. It is kept once something is recorded or imported into it (import_file).
- `rename_video`: Rename one of Your videos, by its id.
- `duplicate_video`: Copy one of Your videos, by its id; returns the copy’s id.
- `delete_video`: Delete one of Your videos, by its id. Only when the person asks: it can be undone for 8 seconds from the note it leaves, then it is gone.
- `close_video`: Close the open video and go back to Your videos.
- `get_project`: Read the open Screen Now video: its clips on the timeline (seconds), where each scene is cut from, camera layouts and changes, zooms, the recordings in it, the spoken transcript with timings, the thumbnail time, and the look and output settings.
- `edit_project`: Edit the video with a list of operations.
- `get_frame`: See the finished picture at a timeline time (background, screen recording, camera, captions), as an image. Look before aiming a zoom: its x/y are 0–1 across the screen recording within the picture, after its crop.
- `seek`: Move the playhead to a timeline time, so the person can see it.
- `undo`: Take back the last edit (one edit_project call is one step).
- `import_file`: Bring a file into the video, as a person importing it: a video becomes a scene, audio the music, an image the background. Give its name and its bytes in base64 (or a data URL). Returns what it became.
- `export_video`: Export an MP4 at the output settings (output.set); a long video takes a while. Returns {ok, error} when it is made: it then waits in the export sheet, whose Download video button saves it (the person, or an agent that can click). Not while recording.
## How edits work
- Times are timeline seconds, except where an op says recording seconds (clip.trim: see each scene’s in, out and sourceDuration).
- apply() takes one op or a list. A list is atomic, all or nothing, and one undo step; undo() takes it back.
- Ops run in order, and each one’s times refer to the timeline as it is when it runs: a 3 s title inserted first moves everything after it by 3 s, so add titles last or allow for them.
- Ids come from get(). apply() returns `created`, the id of the last thing an op made (a zoom, a camera change, a caption, a title).
- Zoom x/y are 0–1 across the screen recording, after its crop. frame(t) is the whole finished picture at a time (background, recording, camera, captions): look before aiming.
- get() and apply() work on the video open in the editor. Your videos: videos() lists them; openVideo(id), newVideo(name?) (kept once something is in it), renameVideo(id, name), duplicateVideo(id) and closeVideo() (back to Your videos). Before deleteVideo(id), ask the person: it can be undone for 8 s from the note it leaves, then it is gone.
- The recorder is for people: the browser asks them what to share, and only they can answer. To show a website or an app, record it yourself (Playwright’s recordVideo, or any screencast of your own browser) and import the file. Otherwise the person records or brings a video, and the agent brings in anything else and edits.
- Media comes in as a file, as a person imports it: importFiles(files), or the import_file tool with the file’s bytes. A video becomes a scene, audio the music, an image the background. Screen Now never fetches anything for an agent.
- Anything wrong comes back as {ok: false, error} saying what would do, and nothing changes.
## What get() shows
- `clips`: scenes and title cards in order, each with `start`/`end` on the timeline; a scene also has where it is cut from its recording (`in`, `out`, `sourceDuration`), its camera `layout` and `cameraChanges`, `zooms`, `crop`, `volume`, and the take it `wears` if a camera was added.
- `recordings`: every recording and imported video, on the timeline or not, with what it has (screen, camera).
- `transcript`: every caption on the timeline, with its id, its clip and when it is said.
- `settings`: output, frame (background, padding, corners, shadow, device), camera bubble, captions, the video's own sound, music, and its background image.
- `poster`: the thumbnail's time, or null when picked automatically.
## Doing it better than by hand
- **Show a website or an app.** Drive it in your own browser with video recording on (Playwright's `recordVideo`, for one), then `newVideo`, `importFiles` the recording, and edit: zoom on what you typed and clicked, caption what happens, add a title. No one has to pick what to share.
- **Tighten it.** In a video with captions, the gaps between transcript lines are pauses. Split at both edges of each long one and remove the piece between, working from the end of the video back, so earlier times don't move under you; then check a frame either side of each cut.
- **Zoom on what is being said.** Find the line in the transcript, look at `frame(t)`, and add a zoom from the line's start for about its length plus a second, aimed at the thing it names (scale 1.5 to 2.2).
- **Show the person when it matters.** A full-screen camera (`layout.add` full) while they introduce themselves; split or side when the face and the screen matter as much as each other; the bubble otherwise.
- **Titles last.** Add the intro (index 0) and the outro (index = the number of clips) after every other edit, since a title moves everything after it.
- **A cut for social.** `output.set` to 9:16 or 1:1, then look at a frame of each scene and adjust layouts, crops and zooms for the new shape.
- **Fix what was misheard** with `caption.update`; light words as they're said with `captions.set` highlight.
- **Check before handing back:** `frame(t)` at each change, then `seek` to the moment you want the person to see.
## Operations
Each with a working example; ids in capitals come from get().
### `project.rename`
Rename the project.
```json
{"op":"project.rename","name":"Launch demo"}
```
### `project.poster`
Pick the frame the video’s thumbnail shows (timeline seconds); null goes back to picking one automatically.
```json
{"op":"project.poster","at":4.2}
```
### `clip.split`
Split the clip under a timeline time into two clips.
```json
{"op":"clip.split","at":12.4}
```
### `clip.trim`
Set the source range (seconds into the recording) a media clip shows.
```json
{"op":"clip.trim","id":"CLIP_ID","in":2,"out":18}
```
### `clip.remove`
Delete a clip from the timeline (its media stays in the project).
```json
{"op":"clip.remove","id":"CLIP_ID"}
```
### `clip.move`
Move a clip to a new position (0 = first).
```json
{"op":"clip.move","id":"CLIP_ID","index":0}
```
### `clip.duplicate`
Duplicate a clip right after itself.
```json
{"op":"clip.duplicate","id":"CLIP_ID"}
```
### `camera.attach`
Make a camera-only clip the camera (bubble) of a clip with a screen, lined up start to start; its voice and captions come along. The camera clip leaves the timeline; if it is longer than the target, the rest stays as a camera-only clip right after it. A camera shorter than the target bows out when its footage ends.
```json
{"op":"camera.attach","id":"CAMERA_CLIP_ID","to":"SCREEN_CLIP_ID"}
```
### `camera.over`
Talk over a run of screen clips with a camera-only recording (`take`: its sourceId): from clip `from`, starting `at` seconds into the take, each clip in the run wears the next part of the take as its bubble (voice and captions too), until a clip without a screen or the end of the take. What is said after the run stays as its own camera clip. The take’s own clip stays on the timeline.
```json
{"op":"camera.over","take":"SOURCE_ID_OF_THE_TAKE","from":"SCREEN_CLIP_ID","at":0}
```
### `camera.detach`
Take an added camera (camera.attach or camera.over; addedCamera: true) off a clip: the clip gets its own sound and captions back, and the part of the take it showed returns as a camera-only clip right after it.
```json
{"op":"camera.detach","id":"CLIP_ID"}
```
### `clip.update`
Change a clip: its default camera layout (off | bubble | side | split | full), volume (0–2: its own sound) and, on a scene wearing a camera take, cameraVolume (0–2: that take’s voice), the transition INTO it (cut | dissolve | fade | slide | rise, 0.1–2 s; cut has no duration), the crop of its screen recording ({x, y, w, h} as fractions 0–1 of the picture; null for none), or a title card’s title, subtitle and duration (0.5–30 s).
```json
{"op":"clip.update","id":"CLIP_ID","patch":{"layout":"split","transition":{"kind":"dissolve","duration":0.6}}}
```
### `title.add`
Insert a title card: index is its place among the clips (default 0, first); duration 0.5–30 s (default 3); the transition into it defaults to a 0.6 s dissolve. It sits on the frame’s background with its text colour picked to read; over a wallpaper or image the background softens behind the words.
```json
{"op":"title.add","title":"Gift subscriptions","subtitle":"October update","duration":3,"index":0}
```
### `zoom.add`
Zoom into the screen recording around a point: scale 1.1–4 (default 1.8), duration default 3 s, x/y 0–1 within the crop (default 0.5, the middle). While zoomed, the recording grows past the frame’s padding to fill the picture. Only on clips with a screen, and not over another zoom. Good zooms: scale 1.5–2.2, held 2–5 s, on the thing being talked about.
```json
{"op":"zoom.add","at":4.2,"duration":3,"scale":1.8,"x":0.72,"y":0.31}
```
### `zoom.update`
Move, resize or retarget a zoom (timeline seconds).
```json
{"op":"zoom.update","id":"ZOOM_ID","start":4,"end":7.5,"scale":2}
```
### `zoom.remove`
Delete a zoom.
```json
{"op":"zoom.remove","id":"ZOOM_ID"}
```
### `layout.add`
Change the camera layout for part of a clip, e.g. full-screen camera while introducing yourself (off | bubble | side | split | full). It eases in and back out to the clip’s layout.
```json
{"op":"layout.add","at":12,"duration":6,"layout":"full"}
```
### `layout.update`
Move, resize or change a camera change (timeline seconds).
```json
{"op":"layout.update","id":"CHANGE_ID","layout":"split","end":20}
```
### `layout.remove`
Delete a camera change.
```json
{"op":"layout.remove","id":"CHANGE_ID"}
```
### `caption.add`
Add a caption over a media clip.
```json
{"op":"caption.add","at":3,"duration":2.5,"text":"Open the settings"}
```
### `caption.update`
Fix a caption’s text. With the same number of words, each keeps when it was said; otherwise the words are spread over the caption’s time.
```json
{"op":"caption.update","id":"CAPTION_ID","text":"Open the settings"}
```
### `caption.remove`
Delete a caption.
```json
{"op":"caption.remove","id":"CAPTION_ID"}
```
### `frame.set`
Background and frame: padding 0–200, radius 0–80, shadow 0–1, device none | browser | phone | tablet (drawn around the screen recording, following its shape: crop a scene to make it phone-shaped; a phone and a tablet round their own corners), url: the address in a browser’s bar, like linear.app ("" for none: a plain window). background is one of: {kind:"wallpaper", id, palette, seed}, a design drawn from a seed (id: contour | flow | ridges | waves | rays | mesh | moire | haze | stipple | dots | truchet | hex | scales | tilt | ten | blocks | bubbles | orbit | phyllo | hilbert; palette picks a variation, 0 to its count − 1 (contour 4, flow 4, ridges 3, waves 3, rays 3, mesh 3, moire 3, haze 4, stipple 3, dots 3, truchet 4, hex 3, scales 3, tilt 3, ten 3, blocks 3, bubbles 3, orbit 3, phyllo 3, hilbert 3); seed 1–9999 redraws it; leave both out for its first look; blur 0–100 softens it) | {kind:"gradient", from, to} (hex, from the top-left corner to the bottom-right) | {kind:"color", color} | {kind:"image", assetId, blur 0–100}, only the video’s own image (settings.image).
```json
{"op":"frame.set","patch":{"padding":64,"radius":16,"background":{"kind":"wallpaper","id":"flow","palette":0,"seed":2718}}}
```
### `camera.set`
Camera bubble: shape circle | squircle | rectangle, size 0.12–0.5 (of the frame’s short side), corner top-left | top-right | bottom-left | bottom-right, mirror true | false.
```json
{"op":"camera.set","patch":{"shape":"circle","size":0.24,"corner":"bottom-right"}}
```
### `audio.set`
The video’s own sound (voice, tab/system audio): muted silences it all, leaving only the music.
```json
{"op":"audio.set","patch":{"muted":true}}
```
### `captions.set`
Caption display: enabled true | false, size 16–64 (layout units: px of a 1440×900 frame), position bottom | top, highlight true | false (light each word as it is said).
```json
{"op":"captions.set","patch":{"enabled":true,"position":"bottom"}}
```
### `music.update`
Music volume (0–1) and whether it ducks under speech (true | false). Only when settings.music isn’t null.
```json
{"op":"music.update","patch":{"volume":0.8,"duck":true}}
```
### `output.set`
Output: aspect 16:9 | 16:10 | 4:3 | 1:1 | 4:5 | 9:16, resolution 720 | 1080 | 1440 | 2160 (the short side), fps 30 | 60.
```json
{"op":"output.set","patch":{"aspect":"9:16"}}
```
## What needs a person, and the usual way
Browsers keep two things for the person at the keyboard: the recorder (the browser asks them what screen, camera and microphone to share) and saving an export (its Download button). An agent never needs the recorder: it records a website or app in its own browser and imports the file. Otherwise the person records, or brings a video; the agent brings in anything else (music, an image for the background, another clip) as files and edits; and the person saves the result.
## Privacy
Videos never leave the browser: recording, editing and exporting happen on the person's computer, and nothing is uploaded. Live captions are made on the device. What is sent: anonymous counts (page views, and when a recording, an import or an export is done), cookieless and never about what's in a video; and feedback, only when a person sends it, with what they wrote. Agents driving the page work under their own privacy terms.
## Links
- [Screen Now](https://screen.now): the app
- [Privacy & Terms](https://screen.now/privacy)
- [@renatoworks](https://x.com/renatoworks): questions, ideas