Skip to content
Recorded calls for AI products

Every call is recorded by default.

For small teams building AI interviews, user research, candidate screening and coaching. Replay and an MP4 export are included. An MCP server lets a coding agent set it up.

Try the live demo A two-way call in your browser, recorded as it happens. No account needed.

Give this to your coding agent

Read https://synento.com/llms.txt, then add live video to this app with Synento. Prove it works by reading back the session manifest.

agent · synento
  1. Reading llms.txt and the quickstart…curl -s https://synento.com/llms.txt
  2. Creating a session (Idempotency-Key set, safe to retry)POST /v1/sessions Idempotency-Key: call-7f3a
  3. Minting a connection token on the serverPOST /v1/sessions/sess_7f3a/connection
  4. Two browsers joined, camera and mic publishing
  5. Reading the session manifest back…GET /v1/sessions/sess_7f3a/manifest
  6. Verified: 2 participants, cam + mic, media landed
LiveRecorded as it happens
Each participant's tracks append to durable streams. The live call and the recording are the same bytes.
  • Always recorded

    Every session is its own recording. There is no recording API to call.

  • Instant replay

    Play it back the moment the call ends. Nothing to process or wait for.

  • No media servers

    Nothing for you to deploy, scale or get paged about.

  • Safe retries

    Session creates are idempotent, so an agent that retries never makes a duplicate call.

The agent loop

Agents write plausible code. Synento lets them prove it works.

Agent-written video usually fails in silence: the code compiles, the call connects, and no media ever arrives. With Synento the agent can check. The recording is the proof.

  1. Discover

    Your agent reads llms.txt, markdown docs and an OpenAPI 3.1 spec, instead of scraping pages or guessing endpoints.

  2. Provision

    Create a project and a session over plain REST. Session creates accept an Idempotency-Key, so a retry never makes a duplicate.

  3. Integrate

    Mint a short-lived connection token on the server and join from the browser with @synento/client. Two packages and one route.

  4. Verify

    Read the session manifest. A track with a non-null start_ts is media that really arrived: camera, mic and screen, per participant.

GET /v1/sessions/:id/manifest
{
  "user_id": "alice",
  "tracks": [
    { "kind": "cam", "start_ts": 1790182704171 },
    { "kind": "mic", "start_ts": 1790182704188 }
  ]
}
{
  "user_id": "bob",
  "tracks": [
    { "kind": "cam", "start_ts": 1790182706412 },
    { "kind": "mic", "start_ts": 1790182706430 }
  ]
}
The manifest lists each participant's tracks with the timestamps of real frames, which a status code cannot show.

How it works

One durable stream for live, replay and export

Browsers encode with WebCodecs and send binary frames to the relay. The relay forwards them to live viewers and appends the same bytes to per-participant durable streams. Replay reads those bytes as they were sent. Only MP4 export re-encodes, to compose the layout you ask for. Nothing is recorded twice.

Diagram: browsers send frames to the Synento relay, which delivers them to live viewers, writes them to durable streams for replay and MP4 export, and sends webhooks as the session progresses.

Browser

WebCodecs encode

Synento relay

Never decodes a frame

Durable streams

One per track

  • Live viewers
  • Replay
  • MP4 export
  • Webhooks

Platform

What a video platform should do, without what it shouldn't need.

  • Recording isn't an add-on

    The live session and the recording are the same streams. There is no recording job and no surcharge. Recordings are kept for up to 7 days on Free and up to 90 on pay-as-you-go.

  • No media servers to operate

    No SFU to deploy, scale or get paged about. Our relay forwards live frames without ever decoding them.

  • Reconnects are boring

    The SDK reconnects on its own with backoff, mints a fresh token and republishes your tracks. Everything sent before the drop is already stored, so a dropped network leaves a gap in the timeline, not a lost call.

  • Layout is a playback decision

    Camera, mic and screen are stored as separate tracks with an event timeline. Pick grid, presenter or active speaker when you play back.

  • Transcripts by speaker

    Turn on post-call transcripts and every session comes back as text, line by line, with who said it and in their own language. Billed on speech only: silence and muted time are never counted. As JSON, WebVTT, SRT, or captions in replay.

  • Signed webhooks

    session.created, session.started, session.ended, recording.ready, export.completed, transcript.ready and participant join and leave events, signed with HMAC-SHA256 and retried with exponential backoff.

  • Redaction built in

    Remove one participant's camera, mic and screen from a recording with a single API call. Chat and any MP4 already exported are kept, so delete the session when a request covers those too.

Developer experience

From zero to a live call with two packages

Your API key stays on your server. The browser only ever sees a short-lived token scoped to one session and one user.

Learn more about API & SDKs
app/api/synento/route.ts
import { resolveWsUrl, SynentoClient } from '@synento/node'

// Reads SYNENTO_API_KEY and SYNENTO_API_URL. Server-side only.
const synento = new SynentoClient()

// Once per call. The session is already its own recording.
export async function createCall() {
  const session = await synento.createSession({ name: 'Standup' })
  return session.id
}

// Once per participant: a short-lived token scoped to one session and user.
export async function POST(request: Request) {
  const { sessionId, userId } = await request.json()
  const token = await synento.createConnectionToken(sessionId, { userId })

  return Response.json({
    token: token.accessToken,
    wsUrl: resolveWsUrl({
      apiBaseUrl: process.env.SYNENTO_API_URL!,
      requestOrigin: request.headers.get('origin'),
      sessionId,
      userId,
    }),
  })
}
Create a session and mint a connection token. The API key never reaches the browser.

Pricing

Start free. Then pay as you go, with no monthly fee

10,000 participant-minutes free every month, no card needed, with recordings kept for up to 7 days. Free accounts pause at the allowance and are never billed.

Past that, pay as you go at $0.003 per participant-minute, recording included. No monthly fee, no recording surcharge.

  • Every session recorded, with no add-on
  • Instant replay and windowed playback
  • MP4 export
View pricing

Compatibility

Runs wherever WebCodecs runs

The SDK checks browser support before a call starts, so a browser that can't take part is told why instead of joining silently.

Supported browsers
BrowserSupported from
Chrome and Edge94+
Safari (macOS and iOS)16.4+
Firefox133+
Older browsersDetected before the call

FAQ

Questions

What does "agent-native" mean?

An AI coding agent can take Synento from nothing to a working, verified integration without anyone clicking through a dashboard. Docs are machine-readable, the API has an OpenAPI spec, session creates are idempotent, and the agent checks that media arrived by reading the recording back.

Is there an MCP server?

Yes. Point your agent at the Synento MCP server and approve it in your browser. It creates projects and sessions, mints a restricted key for your app, runs a synthetic test call, and verifies that camera and microphone arrived. It never holds an owner key. Agents without MCP still have the REST API, the OpenAPI spec and the markdown docs.

What video and audio quality do calls have?

Cameras are sent at up to 720p (1280×720) and 30 frames a second, in the camera's own shape. A phone held upright stays portrait and nothing is cropped. A camera that can't reach 720p is sent at its own size. Video is H.264, using the High profile where the browser can encode it, and audio is Opus at 32 kbps, 16 kHz mono, which suits speech. The recording is the stream the call carried, so replay looks exactly like the live call. MP4 exports are 1280×720 or 720×1280. You can raise or lower the resolution and bitrate per call. Every viewer receives the same stream. There is no per-viewer quality switching (simulcast) yet, and on a congested connection the frame rate drops while the resolution stays the same.

Why WebCodecs rather than WebRTC?

WebRTC is built for ephemeral peer-to-peer media. Synento writes every frame to a durable stream, which is why recording, replay and export come with every session instead of as add-ons. The trade-off is latency. Every frame goes through our relay, so it is higher than peer-to-peer WebRTC.

What does recording cost?

Nothing extra. You pay per participant-minute past the free allowance, and recordings are stored free for their first 30 days. There is no separate recording rate, because there is no separate recording. Replay and MP4 exports have free monthly allowances too; past them, pay-as-you-go bills them per participant-minute. Recordings are kept for up to 7 days on Free and up to 90 on pay-as-you-go.

Can I self-host Synento?

No. Synento is fully hosted. There are no media servers for you to run. If self-hosting is a hard requirement, our LiveKit comparison explains when LiveKit is the better choice.

How do I get started?

Sign up with an email address. Once it is verified, create an API key, or connect your coding agent to Synento's MCP server and let it set up the project itself. The Free plan needs no credit card.

Record the calls your product runs on.

Sign up for a free account. Replay and MP4 export are included, and a coding agent can set the integration up from llms.txt.