Skip to content
Tonta
CapabilitiesPlatformsModelsAutomationPricingShowcase
Sign inStart creating

Make

  • Short-form reels
  • Clips from long-form
  • Episodic series
  • Animated series
  • Virtual influencer
  • Brand content
  • Product & UGC ads
  • Explainer or course video
  • Translate & dub
  • Publishing
  • Creator workspace
  • 3D models

Platform

  • Platforms
  • Models
  • Pricing
  • Showcase
  • How it works
  • Automation

Developers

  • Overview
  • MCP
  • API
  • Changelog

Company

  • Terms
  • Privacy
  • Acceptable use
  • AI disclosure
  • Refunds & credits
  • Report content
  • Status
Tonta
© 2026 Tonta. All rights reserved.AI disclosureRefunds are credit, never cash

REST API

Everything Create does, from your own code.

Every creative system, the storyboard and its edits, projects, references, schedules and publishing, with signed webhooks and live streams instead of polling. A few decisions stay with a signed-in person by design. The list below is generated from the same contract the server enforces.

OpenAPI 3.1 document

Authentication

Send a workspace API key as a bearer token — never a session cookie, never a password. The key decides the workspace; no request takes a workspace id. A key looks like tonta_live_<16 hex>_<random>, is shown once at creation and stored hashed; its prefix is shown in the dashboard so a leaked key can be identified. Each key carries scopes, and an operation outside them is refused. An API key can be limited to one brand. A workspace key, with no brand set, reaches every brand. A workspace holds a small number of active keys (two by default) so you can rotate without downtime; rotating from the dashboard issues the replacement and keeps the old key working for 24 hours. Each key can carry its own daily spend limit, and its recent requests are listed in the dashboard. Scopes are read or write per area: jobs (creating, planning and running work, the only scope that spends credit), assets and references, projects and story, schedules, publishing, connections, brands, knowledge, goals, and usage and billing to read. Managing keys and webhook endpoints is done in the dashboard, not with a key.

jobs:readjobs:writeassets:readassets:writeprojects:writeschedule:readschedule:writepublish:writeconnections:writeusage:readgoals:readgoals:writebilling:readbrands:readbrands:writeknowledge:readknowledge:write

Spending: estimate, quote, start

Nothing that costs credit runs without a quote. Price the work first (create or estimate_job returns a quote that is single-use and good for five minutes), then start it with that quote's id. A storyboard edit returns its price change without spending, and a fresh quote comes from resume_draft. Each key has its own daily spend limit. Above your workspace's confirmation limit the call is refused with confirmation_required, a job.approval_needed webhook and an approval link a signed-in person opens; retry the same call after they approve. An owner may pre-approve a key up to an amount per job and per day, set while signed in. Operations that spend are marked in the table below.

What stays with a person

Approving a spend above your limit, recording consent for a face, a voice or a music track, approving a schedule, approving what goes out to your social accounts, and anything that changes billing are not callable with a key. Your integration can prepare all of it and is told by webhook when a person is needed.

Idempotency

Operations that start work or schedule a post accept an idempotency key. Send it as the Idempotency-Key header, or as the idempotencyKey field in the body — if you send both they must be the same value, or the request is refused with 400. The key is scoped to your workspace and to the operation. Retry with the same key after a timeout and you get the first call's result, never a second charge or a second post; the same key with a different request is a 409. Use a fresh key (a UUID) for each thing you mean to do, and reuse it only to retry that same thing. The operations that accept one are marked in the table below.

Webhooks

Polling a job for twenty minutes is a bad integration, so Tonta pushes: jobs, plans and storyboards, questions waiting for an answer, schedules and their runs, posts, connections, credit and payments. The full list is below, read from the server's own catalogue, and every payload is documented in the OpenAPI document under webhooks.

  • · Signed: tonta-signature: t=<unix>,v1=<hex HMAC-SHA256 of "t.body"> — reject a timestamp more than 300 seconds old.
  • · During a secret rotation the header carries several v1= entries, newest first — accept the request if any one matches.
  • · Every delivery also carries tonta-event-id (the dedupe key — deliveries are at least once and can repeat or arrive out of order) and tonta-event-type.
  • · Retried on any non-2xx, up to 8 delivery attempts, with backoff. An endpoint that fails 15 deliveries in a row is switched off and your owners and admins are emailed; turn it back on from the dashboard and the waiting deliveries are sent again.
  • · Deliveries to one endpoint are sent one at a time, oldest first; separate endpoints are served in parallel.
  • · Every attempt is listed in the dashboard, with a manual replay.
  • · Send a test event to an endpoint from the dashboard to check your signature handling before going live; the dashboard lists the full event catalogue.
add_on.suspendedAn add-on paid from credit could not renew because the balance was short, so it is paused (never deleted). It resumes on the next renewal the balance covers.
api_key.spend_thresholdOne of your API keys crossed a share of its daily spending cap today (50%, 80% or 100%). Sent once per key, per threshold, per UTC day.
automation.endedA schedule reached the end date it was given and stopped making new pieces.
automation.episode_needs_confirmationThe next episode of a series costs more than your confirmation limit, so it was not started on its own. A person starts it from the series after seeing the price.
automation.paused_for_creditA schedule paused because the balance could not cover its next run. Nothing was deleted; it resumes after a top-up.
automation.run_deferredA schedule’s run was moved later rather than skipped: the platform was busy (deferred_congestion, retried at retryAt) or the brand declared a closure (closure). The slot is kept.
automation.run_skippedA schedule’s run did not go ahead for one slot. reason is a closed category: missed_slot, not_ready, cost_blocker, spend_cap, ended, error, insufficient_credit, series_in_progress or episode_plan_needs_attention. Nothing was spent on it.
automation.runway_shortThe balance will not cover a schedule’s upcoming runs. Sent before anything pauses, so there is time to top up.
connection.reauth_requiredA connected account was signed out on its platform; its scheduled posts are paused until it is reconnected.
credit.exhaustedThe credit balance reached zero.
credit.lowThe credit balance is low, or will not cover the scheduled work.
job.approval_neededA spend your integration asked for is waiting for a person to approve it: over your confirmation limit, or over the API key’s standing pre-approval. Open approvalUrl signed in to approve; nothing is charged until then.
job.awaiting_inputA job is waiting for an answer. Its credit hold stays reserved until it is answered or expires.
job.canceledA job was cancelled. Credit not consumed is released; chargedMicroUsd is what was genuinely spent before it stopped.
job.completedA job reached a successful end state: delivered, or published when it publishes.
job.failedA job failed. Credit not consumed is released; chargedMicroUsd is what was genuinely spent.
job.needs_reviewA job is held for a person to review before it continues.
job.queuedA job was admitted to your queue. It starts when one of your jobs at once is free; get_capacity and get_job show its position and estimated wait.
job.startedA queued job started work. Sent each time a job leaves the queue, including after a retry re-queues it.
payment.settledA payment went through and what it bought was applied: credit added, a subscription started or renewed, or an add-on bought. Sent once per payment.
piece.readyA piece of content was approved and is ready to use.
plan_run.completedA background plan finished. Read it with get_plan_run: the plan, a review, or a question.
plan_run.failedA background plan could not be made. code is the stable error code get_plan_run reports; only planning work genuinely done is charged.
plan.revisedA new revision of a job’s plan was written: a storyboard edit, an applied “Ask for a change”, or an applied alternative. Read get_storyboard or list_plan_revisions for what changed.
post.failedA post failed for good (not a retry). The reason is a closed category: platform_unavailable, platform_rate_limited, platform_rejected, content_policy, account_needs_reconnect, not_ready_to_publish or unknown.
post.held_over_capAn approved post is still held because the platform’s daily limit for that account and day is full. Move it to another day.
post.missed_approvalA post’s time passed while it waited for approval. Nothing was published and it is never sent late on its own: pick a new time.
post.publishedA scheduled post went out on its platform.
post.review_waitingA piece a schedule made has been waiting for approval and will not go out until it is approved.
publishing.unattended_revokedAutomatic publishing was switched off for a brand (or the whole workspace when brandProfileId is null): pieces now wait for approval. Nothing was taken down.
question.defaultedA question was not answered in time and its stated default was used. The job carried on with it.
question.openedA question was opened for you to answer: on a job, a Create session or a schedule. While it is open on a job, the job waits with its credit reserved. requiresHuman means only a signed-in person can answer it.
reassembly.completedAn edit of a finished piece is ready to look at. chargedMicroUsd is what it cost; anything held and not used was released.
reference.readyA reference picture passed its checks and can be used to generate.
schedule.approvedA schedule’s plan was approved: from now on its runs follow this version of the plan.
storyboard.picture_readyA shot’s opening picture (its key frame) is ready. Read it with get_asset_previews or get_storyboard.
subscription.updatedThe subscription changed: started, renewed, upgraded, downgraded, canceled or lapsed.
upload.readyA file you uploaded was checked and registered, and can be used. If it was uploaded as a reference, referenceId names it; a reference picture is screened next and sends reference.ready when it can generate.
webhook.endpoint_disabledAnother of your endpoints was switched off after repeated failures. Delivered to your other active endpoints that subscribe to it; the disabled one is not told.
webhook.testA test event you asked for from the endpoint settings. Sent to that one endpoint only.

Live streams

For a screen that should move as the work moves, follow a server-sent event stream with the same key. Each frame says what changed; read the matching operation for the full state. A stream closes on an error, so reconnect.

GET /api/v1/jobs/{jobId}/eventsjobs:readFollow one job’s progress live until it reaches an end state.events: progress, error, session_ended
GET /api/v1/jobs/eventsjobs:readFollow every moving job in the workspace live.events: progress, error, session_ended
GET /api/v1/jobs/{jobId}/plan/eventsjobs:readFollow a job’s plan live: a frame each time a new revision is written (a storyboard edit, an applied “Ask for a change”, an applied alternative).events: revision, error, session_ended
GET /api/v1/plan-runs/{planRunId}/eventsjobs:readFollow a background plan until it finishes.events: progress, error, session_ended
GET /api/v1/scenes/{sceneProjectId}/eventsassets:readFollow a 3D scene while an edit is applied.events: scene_progress, error, session_ended
GET /api/v1/sessions/{sessionId}/eventsjobs:readFollow a Create session live: new turns, and its summary and open questions.events: turns, state, error, session_ended

Connection health

The dashboard shows whether each key and webhook endpoint is working: when a key was last used, and whether an endpoint's recent deliveries succeeded, so a broken integration is visible before a customer notices.

Rate limits

Limits are set per operation and shown in the table below. A 429 carries a Retry-After header — wait that many seconds, then retry.

The published surface (v1)

  • Method: GET

    /api/v1/accessibility/options

    Whether the audio description can be turned on right now, with a sentence to show when it cannot.

    Scope: assets:read

    ›Request examples for get_accessibility_options
    curl
    curl -X GET 'https://tonta.media/api/v1/accessibility/options' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getAccessibilityOptions()
  • Method: GET

    /api/v1/assets/{assetId}/lineage

    Where a file came from (the file an edit was made from) and the edits made from it.

    Scope: assets:read

    ›Request examples for get_asset_lineage
    curl
    curl -X GET 'https://tonta.media/api/v1/assets/<assetId>/lineage' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getAssetLineage({
      "assetId": "<assetId>"
    })
  • Method: GET

    /api/v1/assets/{assetId}/operations

    What can be done to one of your files (upscale, remove background, extend, reframe, change voice), with the models that can do it and about what each costs for this file.

    Rate limit: 60 / minute

    Scope: assets:read

    ›Request examples for list_asset_operations
    curl
    curl -X GET 'https://tonta.media/api/v1/assets/<assetId>/operations' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listAssetOperations({
      "assetId": "<assetId>"
    })
  • Method: GET

    /api/v1/calendar/schedulable

    Content cleared to schedule — moderation- and customer-approved — and which of your connections already carry it.

    Scope: assets:read

    ›Request examples for list_schedulable_content
    curl
    curl -X GET 'https://tonta.media/api/v1/calendar/schedulable' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listSchedulableContent()
  • Method: GET

    /api/v1/consent-agreement

    Whether this workspace has a standing consent agreement for the people in its files, its wording, and who accepted it.

    Rate limit: 120 / minute

    Scope: assets:read

    ›Request examples for get_consent_agreement
    curl
    curl -X GET 'https://tonta.media/api/v1/consent-agreement' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getConsentAgreement()
  • Method: GET

    /api/v1/consent-statement

    The consent wording currently in force, with its version.

    Rate limit: 60 / minute

    Scope: assets:read

    ›Request examples for get_consent_statement
    curl
    curl -X GET 'https://tonta.media/api/v1/consent-statement' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getConsentStatement()
  • Method: GET

    /api/v1/exports/{exportId}

    Check a requested project export's status.

    Scope: assets:read

    ›Request examples for get_project_export
    curl
    curl -X GET 'https://tonta.media/api/v1/exports/<exportId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getProjectExport({
      "exportId": "<exportId>"
    })
  • Method: POST

    /api/v1/exports/{exportId}/download

    Get a short-lived download link for a finished project export.

    Rate limit: 30 / minute

    Scope: assets:read

    ›Request examples for project_export_download
    curl
    curl -X POST 'https://tonta.media/api/v1/exports/<exportId>/download' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.projectExportDownload({
      "exportId": "<exportId>"
    })
  • Method: GET

    /api/v1/jobs/{jobId}/bible

    The production bible a run was made from (its cast, places, products and shots), and which revision of the project bible it used.

    Scope: assets:read

    ›Request examples for get_job_bible
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/bible' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getJobBible({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/library

    Your assets, filtered.

    Scope: assets:read

    ›Request examples for list_library
    curl
    curl -X GET 'https://tonta.media/api/v1/library' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listLibrary()
  • Method: GET

    /api/v1/library-capabilities

    What the library can do right now, and its limits.

    Rate limit: 60 / minute

    Scope: assets:read

    ›Request examples for get_library_capabilities
    curl
    curl -X GET 'https://tonta.media/api/v1/library-capabilities' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getLibraryCapabilities()
  • Method: GET

    /api/v1/library-previews

    Short-lived preview links for a page of library tiles. Minted now, never stored.

    Rate limit: 120 / minute

    Scope: assets:read

    ›Request examples for get_asset_previews
    curl
    curl -X GET 'https://tonta.media/api/v1/library-previews?assetIds=%3CassetIds%3E' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getAssetPreviews({
      "assetIds": [
        "<assetIds>"
      ]
    })
  • Method: GET

    /api/v1/library-thumbnails

    Look at up to 12 of your files by id: an assistant receives each as a small picture (a clip as its key frame), captioned. Ids that are not yours are left out. Never a link; for the file itself use get_download_link. Spends nothing.

    Rate limit: 30 / minute

    Scope: assets:read

    ›Request examples for get_asset_thumbnails
    curl
    curl -X GET 'https://tonta.media/api/v1/library-thumbnails?assetIds=%3CassetIds%3E' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getAssetThumbnails({
      "assetIds": [
        "<assetIds>"
      ]
    })
  • Method: GET

    /api/v1/library/{assetId}

    One library asset: its details, tags and retention. Use open_library_asset for a link to the file.

    Rate limit: 120 / minute

    Scope: assets:read

    ›Request examples for get_asset
    curl
    curl -X GET 'https://tonta.media/api/v1/library/<assetId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getAsset({
      "assetId": "<assetId>"
    })
  • Method: POST

    /api/v1/library/{assetId}/download

    Get a short-lived download link for one of your files.

    Rate limit: 60 / minute

    Scope: assets:read

    ›Request examples for download_asset
    curl
    curl -X POST 'https://tonta.media/api/v1/library/<assetId>/download' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.downloadAsset({
      "assetId": "<assetId>"
    })
  • Method: POST

    /api/v1/library/{assetId}/download-link

    Get a short-lived link to download one of your files. It expires at expiresAt; fetch it now, never store it.

    Rate limit: 30 / minute

    Scope: assets:read

    ›Request examples for get_download_link
    curl
    curl -X POST 'https://tonta.media/api/v1/library/<assetId>/download-link' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getDownloadLink({
      "assetId": "<assetId>"
    })
  • Method: POST

    /api/v1/library/{assetId}/inspect

    Look at or listen to one of your files: a picture comes back as an image, a video as up to 8 frames with their times plus its length, shape, whether it has sound and its transcript when one is stored, a sound as its length and stored transcript, a document as its text. Spends nothing (a new transcription is never made here). For the file itself use get_download_link.

    Rate limit: 12 / minute

    Scope: assets:read

    ›Request examples for inspect_asset
    curl
    curl -X POST 'https://tonta.media/api/v1/library/<assetId>/inspect' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.inspectAsset({
      "assetId": "<assetId>"
    })
  • Method: POST

    /api/v1/library/{assetId}/open

    Get a short-lived link to one asset.

    Rate limit: 120 / minute

    Scope: assets:read

    ›Request examples for open_library_asset
    curl
    curl -X POST 'https://tonta.media/api/v1/library/<assetId>/open' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.openLibraryAsset({
      "assetId": "<assetId>"
    })
  • Method: GET

    /api/v1/library/{assetId}/usage

    Where an asset is used, and whether it is safe to archive.

    Rate limit: 60 / minute

    Scope: assets:read

    ›Request examples for get_asset_usage
    curl
    curl -X GET 'https://tonta.media/api/v1/library/<assetId>/usage' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getAssetUsage({
      "assetId": "<assetId>"
    })
  • Method: GET

    /api/v1/pieces/{contentPieceId}/accessibility

    A piece's scene chapters and audio description track.

    Scope: assets:read

    ›Request examples for get_piece_accessibility
    curl
    curl -X GET 'https://tonta.media/api/v1/pieces/<contentPieceId>/accessibility' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getPieceAccessibility({
      "contentPieceId": "<contentPieceId>"
    })
  • Method: GET

    /api/v1/projects

    Your projects, filtered.

    Scope: assets:read

    ›Request examples for list_projects
    curl
    curl -X GET 'https://tonta.media/api/v1/projects' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listProjects()
  • Method: GET

    /api/v1/projects/{projectId}

    Read a project, its recent jobs and its latest export.

    Scope: assets:read

    ›Request examples for get_project
    curl
    curl -X GET 'https://tonta.media/api/v1/projects/<projectId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getProject({
      "projectId": "<projectId>"
    })
  • Method: GET

    /api/v1/projects/{projectId}/bible

    Read a project's recurring cast, places and products.

    Scope: assets:read

    ›Request examples for get_project_bible
    curl
    curl -X GET 'https://tonta.media/api/v1/projects/<projectId>/bible' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getProjectBible({
      "projectId": "<projectId>"
    })
  • Method: GET

    /api/v1/projects/{projectId}/cast

    A project's cast, places and products with their standing choices, and the library's beside them.

    Rate limit: 60 / minute

    Scope: assets:read

    ›Request examples for list_project_cast
    curl
    curl -X GET 'https://tonta.media/api/v1/projects/<projectId>/cast' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listProjectCast({
      "projectId": "<projectId>"
    })
  • Method: GET

    /api/v1/projects/{projectId}/readiness

    Whether this project has the knowledge it needs, and the next question to ask if not.

    Scope: assets:read

    ›Request examples for get_project_readiness
    curl
    curl -X GET 'https://tonta.media/api/v1/projects/<projectId>/readiness' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getProjectReadiness({
      "projectId": "<projectId>"
    })
  • Method: GET

    /api/v1/projects/{projectId}/rights

    The brand assets and music a project uses, each with the basis you stated for using it, or none yet. A piece that uses one with none is not scheduled or published.

    Scope: assets:read

    ›Request examples for get_project_rights
    curl
    curl -X GET 'https://tonta.media/api/v1/projects/<projectId>/rights' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getProjectRights({
      "projectId": "<projectId>"
    })
  • Method: GET

    /api/v1/projects/{projectId}/season

    How a series' automated season stands: the episodes planned ahead of the one being made, what is planned to happen, what waits for your decision, and whether changes are kept automatically.

    Scope: assets:read

    ›Request examples for get_season_status
    curl
    curl -X GET 'https://tonta.media/api/v1/projects/<projectId>/season' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getSeasonStatus({
      "projectId": "<projectId>"
    })
  • Method: GET

    /api/v1/projects/{projectId}/story

    Read a project's story: its arcs and episodes, scenes, canon, threads and episode recaps.

    Scope: assets:read

    ›Request examples for get_project_story
    curl
    curl -X GET 'https://tonta.media/api/v1/projects/<projectId>/story' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getProjectStory({
      "projectId": "<projectId>"
    })
  • Method: GET

    /api/v1/projects/{projectId}/story/variants

    The alternate versions of one scene or episode, with the live record beside them.

    Scope: assets:read

    ›Request examples for list_story_variants
    curl
    curl -X GET 'https://tonta.media/api/v1/projects/<projectId>/story/variants?subjectType=scene&subjectId=%3CsubjectId%3E' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listStoryVariants({
      "projectId": "<projectId>",
      "subjectType": "scene",
      "subjectId": "<subjectId>"
    })
  • Method: POST

    /api/v1/projects/{projectId}/story/variants/compare

    Two versions of a scene or episode side by side, field by field. Each side is an alternate, or null for the live record.

    Scope: assets:read

    ›Request examples for compare_story_variants
    curl
    curl -X POST 'https://tonta.media/api/v1/projects/<projectId>/story/variants/compare' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"subjectType":"scene","subjectId":"<subjectId>","leftVariantId":"<leftVariantId>","rightVariantId":"<rightVariantId>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.compareStoryVariants({
      "projectId": "<projectId>",
      "subjectType": "scene",
      "subjectId": "<subjectId>",
      "leftVariantId": "<leftVariantId>",
      "rightVariantId": "<rightVariantId>"
    })
  • Method: GET

    /api/v1/projects/{projectId}/story/warnings

    Everything open about the continuity of a project: plans made before something changed, contradictions with the story, and cast past their review date. Each says where to fix it.

    Scope: assets:read

    ›Request examples for list_continuity_warnings
    curl
    curl -X GET 'https://tonta.media/api/v1/projects/<projectId>/story/warnings' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listContinuityWarnings({
      "projectId": "<projectId>"
    })
  • Method: GET

    /api/v1/projects/{projectId}/storyboard

    A project's storyboard: each episode's shots, grouped under its scenes.

    Scope: assets:read

    ›Request examples for get_project_storyboard
    curl
    curl -X GET 'https://tonta.media/api/v1/projects/<projectId>/storyboard' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getProjectStoryboard({
      "projectId": "<projectId>"
    })
  • Method: GET

    /api/v1/projects/{projectId}/transcript-search

    Search what was said across a project's episodes: the latest captions of each, with who said it.

    Rate limit: 60 / minute

    Scope: assets:read

    ›Request examples for search_series_transcript
    curl
    curl -X GET 'https://tonta.media/api/v1/projects/<projectId>/transcript-search?q=%3Cq%3E' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.searchSeriesTranscript({
      "projectId": "<projectId>",
      "q": "<q>"
    })
  • Method: GET

    /api/v1/projects/{projectId}/world

    Read a project's world bible: tone, era, visual style, lore, glossary and rules.

    Scope: assets:read

    ›Request examples for get_world_bible
    curl
    curl -X GET 'https://tonta.media/api/v1/projects/<projectId>/world' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getWorldBible({
      "projectId": "<projectId>"
    })
  • Method: GET

    /api/v1/recast/templates

    List the Recast template clips (clips Tonta owns or has licensed) you can start from. Empty until some are added: upload your own clip instead.

    Rate limit: 60 / minute

    Scope: assets:read

    ›Request examples for list_recast_templates
    curl
    curl -X GET 'https://tonta.media/api/v1/recast/templates' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listRecastTemplates()
  • Method: GET

    /api/v1/references

    Your references, and whether each may be used.

    Rate limit: 60 / minute

    Scope: assets:read

    ›Request examples for list_references
    curl
    curl -X GET 'https://tonta.media/api/v1/references' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listReferences()
  • Method: GET

    /api/v1/references/{referenceId}

    One reference, with its current images in conditioning order.

    Scope: assets:read

    ›Request examples for get_reference
    curl
    curl -X GET 'https://tonta.media/api/v1/references/<referenceId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getReference({
      "referenceId": "<referenceId>"
    })
  • Method: GET

    /api/v1/references/{referenceId}/split-offer

    The separate things a reference picture shows, offered as references of their own (null when there are fewer than two), and the latest split.

    Rate limit: 60 / minute

    Scope: assets:read

    ›Request examples for get_reference_split_offer
    curl
    curl -X GET 'https://tonta.media/api/v1/references/<referenceId>/split-offer' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getReferenceSplitOffer({
      "referenceId": "<referenceId>"
    })
  • Method: GET

    /api/v1/references/{referenceId}/splits/{splitId}

    How a reference split is going and, once done, the references it made.

    Rate limit: 120 / minute

    Scope: assets:read

    ›Request examples for get_reference_split
    curl
    curl -X GET 'https://tonta.media/api/v1/references/<referenceId>/splits/<splitId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getReferenceSplit({
      "referenceId": "<referenceId>",
      "splitId": "<splitId>"
    })
  • Method: GET

    /api/v1/references/{referenceId}/video-identity

    Whether the person in this video can be offered as a voice, a look and a place, and whether you have confirmed it.

    Rate limit: 120 / minute

    Scope: assets:read

    ›Request examples for get_video_identity
    curl
    curl -X GET 'https://tonta.media/api/v1/references/<referenceId>/video-identity' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getVideoIdentity({
      "referenceId": "<referenceId>"
    })
  • Method: GET

    /api/v1/references/{referenceId}/voice-design-suggestion

    A description of how a voice sample sounds (pitch, pace, tone, accent), to start a designed voice from with estimate_voice_design. Never a clone. Null while the sample is being listened to or when nothing was measured.

    Rate limit: 30 / minute

    Scope: assets:read

    ›Request examples for get_voice_design_suggestion
    curl
    curl -X GET 'https://tonta.media/api/v1/references/<referenceId>/voice-design-suggestion' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getVoiceDesignSuggestion({
      "referenceId": "<referenceId>"
    })
  • Method: POST

    /api/v1/references/previews

    Get short-lived preview links for a set of references.

    Rate limit: 120 / minute

    Scope: assets:read

    ›Request examples for get_reference_previews
    curl
    curl -X POST 'https://tonta.media/api/v1/references/previews' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"referenceIds":["<referenceIds>"]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getReferencePreviews({
      "referenceIds": [
        "<referenceIds>"
      ]
    })
  • Method: GET

    /api/v1/references/role-suggestions

    Server-owned suggested asset roles for a reference kind, before any reference exists.

    Rate limit: 60 / minute

    Scope: assets:read

    ›Request examples for get_reference_role_suggestions
    curl
    curl -X GET 'https://tonta.media/api/v1/references/role-suggestions?kind=character_sheet' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getReferenceRoleSuggestions({
      "kind": "character_sheet"
    })
  • Method: POST

    /api/v1/review/{contentPieceId}/downloads

    Download links for every cut of one piece.

    Rate limit: 30 / minute

    Scope: assets:read

    ›Request examples for piece_downloads
    curl
    curl -X POST 'https://tonta.media/api/v1/review/<contentPieceId>/downloads' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.pieceDownloads({
      "contentPieceId": "<contentPieceId>"
    })
  • Method: GET

    /api/v1/scene-templates

    List the starter 3D scenes you can begin from.

    Rate limit: 60 / minute

    Scope: assets:read

    ›Request examples for list_scene_templates
    curl
    curl -X GET 'https://tonta.media/api/v1/scene-templates' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listSceneTemplates()
  • Method: GET

    /api/v1/scenes

    List this workspace’s 3D scenes, newest first.

    Rate limit: 60 / minute

    Scope: assets:read

    ›Request examples for list_scene_projects
    curl
    curl -X GET 'https://tonta.media/api/v1/scenes' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listSceneProjects()
  • Method: GET

    /api/v1/scenes/{sceneProjectId}/compute-calls

    List a scene’s billed compute calls, newest first.

    Rate limit: 60 / minute

    Scope: assets:read

    ›Request examples for list_scene_compute_calls
    curl
    curl -X GET 'https://tonta.media/api/v1/scenes/<sceneProjectId>/compute-calls' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listSceneComputeCalls({
      "sceneProjectId": "<sceneProjectId>"
    })
  • Method: GET

    /api/v1/storage/usage

    What your library stores against your plan allowance, what storage and delivery above it would cost, and what you could free.

    Rate limit: 20 / minute

    Scope: assets:read

    ›Request examples for get_storage_usage
    curl
    curl -X GET 'https://tonta.media/api/v1/storage/usage' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getStorageUsage()
  • Method: GET

    /api/v1/story/comments

    The comment threads on one story record, open threads first.

    Scope: assets:read

    ›Request examples for list_story_comments
    curl
    curl -X GET 'https://tonta.media/api/v1/story/comments?subjectType=entity&subjectId=%3CsubjectId%3E' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listStoryComments({
      "subjectType": "entity",
      "subjectId": "<subjectId>"
    })
  • Method: GET

    /api/v1/story/consent-blocks

    Drafts and scheduled runs on hold because permission for someone in them was withdrawn. They start again once planned without them.

    Scope: assets:read

    ›Request examples for list_consent_blocks
    curl
    curl -X GET 'https://tonta.media/api/v1/story/consent-blocks' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listConsentBlocks()
  • Method: GET

    /api/v1/story/entities

    Your cast, places and products: a project's own and the library's.

    Rate limit: 60 / minute

    Scope: assets:read

    ›Request examples for list_story_entities
    curl
    curl -X GET 'https://tonta.media/api/v1/story/entities' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listStoryEntities()
  • Method: GET

    /api/v1/story/entities/{entityId}

    One cast member, place or product.

    Scope: assets:read

    ›Request examples for get_story_entity
    curl
    curl -X GET 'https://tonta.media/api/v1/story/entities/<entityId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getStoryEntity({
      "entityId": "<entityId>"
    })
  • Method: GET

    /api/v1/story/entities/{entityId}/consents

    The consent records behind a person, voice or likeness in the story: who attested, as whom, and whether it was withdrawn.

    Scope: assets:read

    ›Request examples for list_entity_consents
    curl
    curl -X GET 'https://tonta.media/api/v1/story/entities/<entityId>/consents' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listEntityConsents({
      "entityId": "<entityId>"
    })
  • Method: GET

    /api/v1/story/entities/{entityId}/page

    A cast member, place or product with where it appears and how it changed over the story. Its history and comments are read with list_story_history and list_story_comments.

    Scope: assets:read

    ›Request examples for get_story_entity_page
    curl
    curl -X GET 'https://tonta.media/api/v1/story/entities/<entityId>/page' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getStoryEntityPage({
      "entityId": "<entityId>"
    })
  • Method: GET

    /api/v1/story/entities/{entityId}/pieces

    The pieces already made with a person or place. Listed, never deleted: a withdrawal leaves you the list to act on.

    Scope: assets:read

    ›Request examples for list_entity_pieces
    curl
    curl -X GET 'https://tonta.media/api/v1/story/entities/<entityId>/pieces' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listEntityPieces({
      "entityId": "<entityId>"
    })
  • Method: GET

    /api/v1/story/entities/{entityId}/states

    How a cast member, place or product changes over the episodes, in order, with the changes waiting for you to accept.

    Rate limit: 60 / minute

    Scope: assets:read

    ›Request examples for list_entity_states
    curl
    curl -X GET 'https://tonta.media/api/v1/story/entities/<entityId>/states' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listEntityStates({
      "entityId": "<entityId>"
    })
  • Method: GET

    /api/v1/story/history

    The history of one story record: every change, who made it, when and why, newest first.

    Scope: assets:read

    ›Request examples for list_story_history
    curl
    curl -X GET 'https://tonta.media/api/v1/story/history?subjectType=entity&subjectId=%3CsubjectId%3E' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listStoryHistory({
      "subjectType": "entity",
      "subjectId": "<subjectId>"
    })
  • Method: GET

    /api/v1/story/introductions

    New characters, places and props proposed for a series, with what accepting does and what it costs.

    Scope: assets:read

    ›Request examples for list_story_introductions
    curl
    curl -X GET 'https://tonta.media/api/v1/story/introductions' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listStoryIntroductions()
  • Method: GET

    /api/v1/story/proposals

    The changes to the story waiting for you to accept or reject (pending by default), with what would change and why.

    Scope: assets:read

    ›Request examples for list_story_proposals
    curl
    curl -X GET 'https://tonta.media/api/v1/story/proposals' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listStoryProposals()
  • Method: GET

    /api/v1/story/stale

    Plans and pieces that depend on something in the story that changed after they were made.

    Scope: assets:read

    ›Request examples for list_story_stale
    curl
    curl -X GET 'https://tonta.media/api/v1/story/stale' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listStoryStale()
  • Method: POST

    /api/v1/story/stale/{markId}/quote

    The price of making again only the shots a change touches. A quote only: nothing is made or charged until you choose to.

    Rate limit: 30 / minute

    Scope: assets:read

    ›Request examples for quote_story_stale_regeneration
    curl
    curl -X POST 'https://tonta.media/api/v1/story/stale/<markId>/quote' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.quoteStoryStaleRegeneration({
      "markId": "<markId>"
    })
  • Method: GET

    /api/v1/story/templates

    The story templates you have saved: a project's arcs, episode outlines, open threads, facts and cast, without pictures or voices.

    Scope: assets:read

    ›Request examples for list_story_templates
    curl
    curl -X GET 'https://tonta.media/api/v1/story/templates' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listStoryTemplates()
  • Method: POST

    /api/v1/automation/{serviceSubscriptionId}/references/accept-proposal

    Turn a suggested library asset into a reference for one plan slot ("Use this?").

    Rate limit: 30 / minute

    Scope: assets:write

    ›Request examples for accept_reference_proposal
    curl
    curl -X POST 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/references/accept-proposal' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"kind":"character_sheet","role":"identity","assetId":"<assetId>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.acceptReferenceProposal({
      "serviceSubscriptionId": "<serviceSubscriptionId>",
      "kind": "character_sheet",
      "role": "identity",
      "assetId": "<assetId>"
    })
  • Method: POST

    /api/v1/library/{assetId}/archive

    Hide an asset from your library. Nothing is deleted. Refused while it is in use or under a hold.

    Rate limit: 60 / minute

    Scope: assets:write

    ›Request examples for archive_asset
    curl
    curl -X POST 'https://tonta.media/api/v1/library/<assetId>/archive' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.archiveAsset({
      "assetId": "<assetId>"
    })
  • Method: PATCH

    /api/v1/library/{assetId}/tags

    Replace the tags on an asset.

    Rate limit: 60 / minute

    Scope: assets:write

    ›Request examples for set_asset_tags
    curl
    curl -X PATCH 'https://tonta.media/api/v1/library/<assetId>/tags' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"tags":["<tags>"]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.setAssetTags({
      "assetId": "<assetId>",
      "tags": [
        "<tags>"
      ]
    })
  • Method: POST

    /api/v1/library/{assetId}/unarchive

    Bring an archived asset back into your library. Also cancels a delete made within the grace period.

    Rate limit: 60 / minute

    Scope: assets:write

    ›Request examples for unarchive_asset
    curl
    curl -X POST 'https://tonta.media/api/v1/library/<assetId>/unarchive' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.unarchiveAsset({
      "assetId": "<assetId>"
    })
  • Method: POST

    /api/v1/projects/{projectId}/export

    Package a project as a zip for download.

    Rate limit: 5 / 300 s

    Scope: assets:writeidempotent

    ›Request examples for request_project_export
    curl
    curl -X POST 'https://tonta.media/api/v1/projects/<projectId>/export' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.requestProjectExport({
      "projectId": "<projectId>",
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: POST

    /api/v1/references/{referenceId}/archive

    Archive a reference: it stops being usable for new work. Nothing is deleted. Refused while a job is using it or it is under a hold.

    Rate limit: 60 / minute

    Scope: assets:write

    ›Request examples for archive_reference
    curl
    curl -X POST 'https://tonta.media/api/v1/references/<referenceId>/archive' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.archiveReference({
      "referenceId": "<referenceId>"
    })
  • Method: POST

    /api/v1/references/{referenceId}/assets

    Set the ordered images behind a reference sheet, replacing whatever was there.

    Rate limit: 30 / minute

    Scope: assets:write

    ›Request examples for set_reference_assets
    curl
    curl -X POST 'https://tonta.media/api/v1/references/<referenceId>/assets' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"assets":[{"assetId":"<assetId>"}]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.setReferenceAssets({
      "referenceId": "<referenceId>",
      "assets": [
        {
          "assetId": "<assetId>"
        }
      ]
    })
  • Method: POST

    /api/v1/references/{referenceId}/brand

    Change a reference's brand, or clear it.

    Rate limit: 30 / minute

    Scope: assets:write

    ›Request examples for set_reference_brand
    curl
    curl -X POST 'https://tonta.media/api/v1/references/<referenceId>/brand' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"brandProfileId":"<brandProfileId>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.setReferenceBrand({
      "referenceId": "<referenceId>",
      "brandProfileId": "<brandProfileId>"
    })
  • Method: POST

    /api/v1/references/{referenceId}/kind

    Reclassify a reference's kind. Moving into a kind that needs consent or rights (a person's likeness, a voice, a music track) makes it unusable until the person confirms on the web: the result carries that page's link.

    Rate limit: 30 / minute

    Scope: assets:write

    ›Request examples for set_reference_kind
    curl
    curl -X POST 'https://tonta.media/api/v1/references/<referenceId>/kind' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"kind":"character_sheet"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.setReferenceKind({
      "referenceId": "<referenceId>",
      "kind": "character_sheet"
    })
  • Method: POST

    /api/v1/references/{referenceId}/split

    Make the chosen items of a picture into references of their own (see get_reference_split_offer). Runs in the background: watch get_reference_split. A person becomes a character reference that needs consent before use. Spends nothing.

    Rate limit: 30 / hour

    Scope: assets:write

    ›Request examples for split_reference
    curl
    curl -X POST 'https://tonta.media/api/v1/references/<referenceId>/split' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"itemIndexes":[1]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.splitReference({
      "referenceId": "<referenceId>",
      "itemIndexes": [
        1
      ]
    })
  • Method: POST

    /api/v1/references/{referenceId}/unarchive

    Bring an archived reference back. A likeness whose consent was withdrawn needs a new consent record first.

    Rate limit: 60 / minute

    Scope: assets:write

    ›Request examples for unarchive_reference
    curl
    curl -X POST 'https://tonta.media/api/v1/references/<referenceId>/unarchive' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.unarchiveReference({
      "referenceId": "<referenceId>"
    })
  • Method: POST

    /api/v1/uploads

    Get a direct upload URL for a file you are about to send — the browser uploads straight to storage.

    Rate limit: 30 / minute

    Scope: assets:write

    ›Request examples for request_upload
    curl
    curl -X POST 'https://tonta.media/api/v1/uploads' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"purpose":"reference_image","filename":"<filename>","contentType":"<contentType>","sizeBytes":1}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.requestUpload({
      "purpose": "reference_image",
      "filename": "<filename>",
      "contentType": "<contentType>",
      "sizeBytes": 1
    })
  • Method: POST

    /api/v1/uploads/{uploadId}/abandon

    Cancel a pending upload that was cancelled or failed, and release its slot.

    Rate limit: 60 / minute

    Scope: assets:write

    ›Request examples for abandon_upload
    curl
    curl -X POST 'https://tonta.media/api/v1/uploads/<uploadId>/abandon' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.abandonUpload({
      "uploadId": "<uploadId>"
    })
  • Method: POST

    /api/v1/uploads/{uploadId}/confirm

    Confirm a direct upload once the file has finished sending, and register it.

    Rate limit: 60 / minute

    Scope: assets:write

    ›Request examples for confirm_upload
    curl
    curl -X POST 'https://tonta.media/api/v1/uploads/<uploadId>/confirm' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.confirmUpload({
      "uploadId": "<uploadId>"
    })
  • Method: POST

    /api/v1/uploads/{uploadId}/multipart/abort

    Cancel an in-progress multipart upload and release its parts at the store.

    Rate limit: 30 / minute

    Scope: assets:write

    ›Request examples for abort_multipart_upload
    curl
    curl -X POST 'https://tonta.media/api/v1/uploads/<uploadId>/multipart/abort' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"multipartUploadId":"<multipartUploadId>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.abortMultipartUpload({
      "uploadId": "<uploadId>",
      "multipartUploadId": "<multipartUploadId>"
    })
  • Method: POST

    /api/v1/uploads/{uploadId}/multipart/complete

    Assemble a multipart upload once every part has been sent, before confirming it.

    Rate limit: 60 / minute

    Scope: assets:write

    ›Request examples for complete_multipart_upload
    curl
    curl -X POST 'https://tonta.media/api/v1/uploads/<uploadId>/multipart/complete' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"multipartUploadId":"<multipartUploadId>","parts":[{"partNumber":1,"eTag":"<eTag>"}]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.completeMultipartUpload({
      "uploadId": "<uploadId>",
      "multipartUploadId": "<multipartUploadId>",
      "parts": [
        {
          "partNumber": 1,
          "eTag": "<eTag>"
        }
      ]
    })
  • Method: POST

    /api/v1/uploads/{uploadId}/multipart/resume

    Resume an interrupted multipart upload: which parts are already stored, and new URLs for the rest.

    Rate limit: 30 / minute

    Scope: assets:write

    ›Request examples for resume_multipart_upload
    curl
    curl -X POST 'https://tonta.media/api/v1/uploads/<uploadId>/multipart/resume' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"multipartUploadId":"<multipartUploadId>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.resumeMultipartUpload({
      "uploadId": "<uploadId>",
      "multipartUploadId": "<multipartUploadId>"
    })
  • Method: GET

    /api/v1/billing/forecast

    An estimate of how many days your balance lasts, from your recent spending.

    Rate limit: 30 / minute

    Scope: billing:read

    ›Request examples for get_balance_forecast
    curl
    curl -X GET 'https://tonta.media/api/v1/billing/forecast' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getBalanceForecast()
  • Method: GET

    /api/v1/billing/invoices

    Your invoices, newest first.

    Rate limit: 60 / minute

    Scope: billing:read

    ›Request examples for list_invoices
    curl
    curl -X GET 'https://tonta.media/api/v1/billing/invoices' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listInvoices()
  • Method: GET

    /api/v1/billing/invoices/{invoiceId}/download

    A short-lived link to download an invoice as a PDF.

    Rate limit: 30 / minute

    Scope: billing:read

    ›Request examples for get_invoice_download
    curl
    curl -X GET 'https://tonta.media/api/v1/billing/invoices/<invoiceId>/download' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getInvoiceDownload({
      "invoiceId": "<invoiceId>"
    })
  • Method: GET

    /api/v1/billing/payments

    Your payment history, paged newest first.

    Scope: billing:read

    ›Request examples for list_payments
    curl
    curl -X GET 'https://tonta.media/api/v1/billing/payments' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listPayments()
  • Method: GET

    /api/v1/billing/payments/{paymentId}

    One payment of yours, by id.

    Scope: billing:read

    ›Request examples for get_payment
    curl
    curl -X GET 'https://tonta.media/api/v1/billing/payments/<paymentId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getPayment({
      "paymentId": "<paymentId>"
    })
  • Method: GET

    /api/v1/billing/spend-controls

    Your monthly cap, what is committed against it, and your balance-alert settings.

    Rate limit: 60 / minute

    Scope: billing:read

    ›Request examples for get_spend_controls
    curl
    curl -X GET 'https://tonta.media/api/v1/billing/spend-controls' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getSpendControls()
  • Method: GET

    /api/v1/brands/{brandProfileId}/wallet

    The credit wallet of one brand: balance, what is reserved, whether it may use the workspace balance, and recent transfers.

    Rate limit: 60 / minute

    Scope: billing:read

    ›Request examples for get_brand_wallet
    curl
    curl -X GET 'https://tonta.media/api/v1/brands/<brandProfileId>/wallet' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getBrandWallet({
      "brandProfileId": "<brandProfileId>"
    })
  • Method: GET

    /api/v1/brand-form-spec

    The setup form for one kind of brand: sections, fields, labels and help.

    Scope: brands:read

    ›Request examples for get_brand_form_spec
    curl
    curl -X GET 'https://tonta.media/api/v1/brand-form-spec' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getBrandFormSpec()
  • Method: GET

    /api/v1/brands

    Every brand this workspace makes content for.

    Scope: brands:read

    ›Request examples for list_brand_profiles
    curl
    curl -X GET 'https://tonta.media/api/v1/brands' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listBrandProfiles()
  • Method: GET

    /api/v1/brands/{brandProfileId}

    One brand, its offerings, and what we know about it.

    Scope: brands:read

    ›Request examples for get_brand_profile
    curl
    curl -X GET 'https://tonta.media/api/v1/brands/<brandProfileId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getBrandProfile({
      "brandProfileId": "<brandProfileId>"
    })
  • Method: GET

    /api/v1/brands/{brandProfileId}/events

    A brand's calendar — launches, sales, seasons, appearances.

    Scope: brands:read

    ›Request examples for list_brand_events
    curl
    curl -X GET 'https://tonta.media/api/v1/brands/<brandProfileId>/events' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listBrandEvents({
      "brandProfileId": "<brandProfileId>"
    })
  • Method: GET

    /api/v1/brands/lookup

    The brands you can make content for: id, name and kind, to name one on other calls.

    Rate limit: 120 / minute

    Scope: brands:read

    ›Request examples for list_brands
    curl
    curl -X GET 'https://tonta.media/api/v1/brands/lookup' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listBrands()
  • Method: POST

    /api/v1/brands

    Create a brand to make content for.

    Rate limit: 20 / hour

    Scope: brands:write

    ›Request examples for create_brand_profile
    curl
    curl -X POST 'https://tonta.media/api/v1/brands' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"name":"<name>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.createBrandProfile({
      "name": "<name>"
    })
  • Method: PATCH

    /api/v1/brands/{brandProfileId}

    Edit a brand.

    Rate limit: 60 / hour

    Scope: brands:write

    ›Request examples for update_brand_profile
    curl
    curl -X PATCH 'https://tonta.media/api/v1/brands/<brandProfileId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"name":"<name>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.updateBrandProfile({
      "brandProfileId": "<brandProfileId>",
      "name": "<name>"
    })
  • Method: POST

    /api/v1/brands/{brandProfileId}/events

    Add a launch, sale, season or other event the plan should build toward.

    Rate limit: 100 / hour

    Scope: brands:write

    ›Request examples for create_brand_event
    curl
    curl -X POST 'https://tonta.media/api/v1/brands/<brandProfileId>/events' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"name":"<name>","kind":"launch","startsAt":"2026-10-09T09:00:00.000Z"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.createBrandEvent({
      "brandProfileId": "<brandProfileId>",
      "name": "<name>",
      "kind": "launch",
      "startsAt": "2026-10-09T09:00:00.000Z"
    })
  • Method: PATCH

    /api/v1/brands/{brandProfileId}/events/{eventId}

    Edit an event on a brand's calendar.

    Rate limit: 100 / hour

    Scope: brands:write

    ›Request examples for update_brand_event
    curl
    curl -X PATCH 'https://tonta.media/api/v1/brands/<brandProfileId>/events/<eventId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"name":"<name>","kind":"launch","startsAt":"2026-10-09T09:00:00.000Z"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.updateBrandEvent({
      "brandProfileId": "<brandProfileId>",
      "eventId": "<eventId>",
      "name": "<name>",
      "kind": "launch",
      "startsAt": "2026-10-09T09:00:00.000Z"
    })
  • Method: POST

    /api/v1/brands/{brandProfileId}/offerings

    Add or edit one thing a brand sells or offers.

    Rate limit: 100 / hour

    Scope: brands:write

    ›Request examples for upsert_offering
    curl
    curl -X POST 'https://tonta.media/api/v1/brands/<brandProfileId>/offerings' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"kind":"product","name":"<name>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.upsertOffering({
      "brandProfileId": "<brandProfileId>",
      "kind": "product",
      "name": "<name>"
    })
  • Method: DELETE

    /api/v1/events/{eventId}

    Remove an event from a brand's calendar.

    Rate limit: 100 / hour

    Scope: brands:write

    ›Request examples for delete_brand_event
    curl
    curl -X DELETE 'https://tonta.media/api/v1/events/<eventId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.deleteBrandEvent({
      "eventId": "<eventId>"
    })
  • Method: POST

    /api/v1/offerings/{offeringId}/archive

    Retire something a brand no longer sells or offers.

    Rate limit: 100 / hour

    Scope: brands:write

    ›Request examples for archive_offering
    curl
    curl -X POST 'https://tonta.media/api/v1/offerings/<offeringId>/archive' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.archiveOffering({
      "offeringId": "<offeringId>"
    })
  • Method: POST

    /api/v1/connections/complete

    Finish connecting a platform after the vendor redirect returns.

    Rate limit: 20 / minute

    Scope: connections:write

    ›Request examples for complete_connection
    curl
    curl -X POST 'https://tonta.media/api/v1/connections/complete' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"brandProfileId":"<brandProfileId>","platform":"<platform>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.completeConnection({
      "brandProfileId": "<brandProfileId>",
      "platform": "<platform>"
    })
  • Method: POST

    /api/v1/connections/start

    Get a link to connect one platform for a brand.

    Rate limit: 10 / minute

    Scope: connections:write

    ›Request examples for start_connection
    curl
    curl -X POST 'https://tonta.media/api/v1/connections/start' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"platform":"<platform>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.startConnection({
      "platform": "<platform>"
    })
  • Method: GET

    /api/v1/goal-metrics

    Every metric a goal may be set on.

    Scope: goals:read

    ›Request examples for list_goal_metrics
    curl
    curl -X GET 'https://tonta.media/api/v1/goal-metrics' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listGoalMetrics()
  • Method: GET

    /api/v1/goals

    Every goal for this workspace, grouped by whether it is proposed, active or past.

    Scope: goals:read

    ›Request examples for list_goals
    curl
    curl -X GET 'https://tonta.media/api/v1/goals' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listGoals()
  • Method: GET

    /api/v1/home/categories

    Every subject Tonta has ready ideas for (music, dance, history, animation, boxing and more), with its ideas.

    Scope: goals:read

    ›Request examples for list_idea_categories
    curl
    curl -X GET 'https://tonta.media/api/v1/home/categories' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listIdeaCategories()
  • Method: POST

    /api/v1/goals

    Propose a measurable target. Always created proposed, never active.

    Rate limit: 30 / minute

    Scope: goals:write

    ›Request examples for propose_goal
    curl
    curl -X POST 'https://tonta.media/api/v1/goals' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"metric":"<metric>","targetValue":"<targetValue>","startsAt":"2026-10-09T09:00:00.000Z","dueAt":"2026-10-09T09:00:00.000Z"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.proposeGoal({
      "metric": "<metric>",
      "targetValue": "<targetValue>",
      "startsAt": "2026-10-09T09:00:00.000Z",
      "dueAt": "2026-10-09T09:00:00.000Z"
    })
  • Method: GET

    /api/v1/account/standing

    This workspace's current abuse-ladder standing, in customer language.

    Scope: jobs:read

    ›Request examples for get_account_standing
    curl
    curl -X GET 'https://tonta.media/api/v1/account/standing' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getAccountStanding()
  • Method: GET

    /api/v1/ads/batches

    Your ad batches, newest first, paged. Started ones by default.

    Scope: jobs:read

    ›Request examples for list_ad_batches
    curl
    curl -X GET 'https://tonta.media/api/v1/ads/batches' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listAdBatches()
  • Method: GET

    /api/v1/ads/batches/{jobId}

    Read an ad batch: each variant with its angle, hook line, shape, state, price, charge and file, grouped for comparison.

    Scope: jobs:read

    ›Request examples for get_ad_batch
    curl
    curl -X GET 'https://tonta.media/api/v1/ads/batches/<jobId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getAdBatch({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/ads/hook-suggestions/price

    Whether hook line suggestions are available, and the most one request for them can cost. Spends nothing.

    Scope: jobs:read

    ›Request examples for get_ad_hook_price
    curl
    curl -X GET 'https://tonta.media/api/v1/ads/hook-suggestions/price' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getAdHookPrice()
  • Method: GET

    /api/v1/asset-operations/{jobId}

    Read one edit of a file: its state, price, charge and the new file once it is ready. Progress also arrives as the job’s own events.

    Scope: jobs:read

    ›Request examples for get_asset_operation
    curl
    curl -X GET 'https://tonta.media/api/v1/asset-operations/<jobId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getAssetOperation({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/capabilities

    Everything Tonta can make and combine in one piece: each mode and sub-mode, each system (motion, picture operations, music, voice-over, dub, captions, Recast, lip sync...), what each needs, what it can be set to, how it is priced, whether a person must attest something, and what it combines with. Spends nothing.

    Rate limit: 30 / minute

    Scope: jobs:read

    ›Request examples for describe_capabilities
    curl
    curl -X GET 'https://tonta.media/api/v1/capabilities' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.describeCapabilities()
  • Method: GET

    /api/v1/capacity

    How much work you can run right now: jobs at once, your queue with positions and waits, this hour, what more you can buy, and your own rate limits.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for get_capacity
    curl
    curl -X GET 'https://tonta.media/api/v1/capacity' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getCapacity()
  • Method: GET

    /api/v1/caption-styles

    The caption styles a piece can use.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for list_caption_styles
    curl
    curl -X GET 'https://tonta.media/api/v1/caption-styles' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listCaptionStyles()
  • Method: GET

    /api/v1/composition/caption-templates

    The caption templates a composition’s captions can use, and the platform safe zones that keep them clear of each platform’s buttons and captions.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for list_caption_templates
    curl
    curl -X GET 'https://tonta.media/api/v1/composition/caption-templates' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listCaptionTemplates()
  • Method: GET

    /api/v1/composition/effects

    The effects a clip can carry, the moves a still picture can make, and the speed changes, each with its settings.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for list_effects
    curl
    curl -X GET 'https://tonta.media/api/v1/composition/effects' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listEffects()
  • Method: GET

    /api/v1/composition/looks

    The colour looks a clip can be graded with, each with what it looks like.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for list_looks
    curl
    curl -X GET 'https://tonta.media/api/v1/composition/looks' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listLooks()
  • Method: GET

    /api/v1/composition/transitions

    The transitions a clip can arrive by (and the fades a last clip or overlay can leave by), each with what it looks like, the directions it takes and its default length.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for list_transitions
    curl
    curl -X GET 'https://tonta.media/api/v1/composition/transitions' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listTransitions()
  • Method: GET

    /api/v1/compositions

    A finished piece as a timeline you can edit: tracks (video, overlays, text, captions, voice, music, effects), clips with trims, speed, keyframes, looks, effects and transitions, markers and the mix. Name the piece, or the job that made it. Spends nothing.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for get_composition
    curl
    curl -X GET 'https://tonta.media/api/v1/compositions' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getComposition()
  • Method: GET

    /api/v1/compositions/in-progress

    The pieces whose timeline has edits saved since their last render (or never rendered), most recently edited first: continue one with get_composition then edit_composition, render it with estimate_render then render_composition, or set its edits aside with discard_composition_edits. Each says how many changes are waiting and gives its editor link. Spends nothing.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for list_compositions_in_progress
    curl
    curl -X GET 'https://tonta.media/api/v1/compositions/in-progress' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listCompositionsInProgress()
  • Method: GET

    /api/v1/content/{contentPieceId}/attempts

    A block's version history.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for list_block_attempts
    curl
    curl -X GET 'https://tonta.media/api/v1/content/<contentPieceId>/attempts' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listBlockAttempts({
      "contentPieceId": "<contentPieceId>"
    })
  • Method: GET

    /api/v1/content/{contentPieceId}/captions

    A piece's captions: the lines, the style, and the subtitle files.

    Rate limit: 120 / minute

    Scope: jobs:read

    ›Request examples for get_caption_track
    curl
    curl -X GET 'https://tonta.media/api/v1/content/<contentPieceId>/captions' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getCaptionTrack({
      "contentPieceId": "<contentPieceId>"
    })
  • Method: GET

    /api/v1/content/{contentPieceId}/composition/clip-actions

    What applies to each clip of a timeline, as it is now: the free edit_composition changes that apply to it, the properties set_property can keyframe on it, and the PAID generative actions (cut out a background, take an object out, change a picture with words, upscale, reframe, change a voice, make a sound effect, picture or clip), each naming the tool that quotes it, start_job to spend that quote, and the edit that puts the new file on the timeline. Editing and rendering an edit are never charged; only these actions are, through their own quote. Spends nothing.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for list_clip_actions
    curl
    curl -X GET 'https://tonta.media/api/v1/content/<contentPieceId>/composition/clip-actions' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listClipActions({
      "contentPieceId": "<contentPieceId>"
    })
  • Method: POST

    /api/v1/content/{contentPieceId}/composition/preview/{renderId}

    Where a preview of a composition is, and once it is ready a short-lived link to play it (360p, watermarked). The link expires at expiresAt: play it now, never store it. A preview cannot be published or downloaded as a piece.

    Rate limit: 120 / minute

    Scope: jobs:read

    ›Request examples for get_composition_preview
    curl
    curl -X POST 'https://tonta.media/api/v1/content/<contentPieceId>/composition/preview/<renderId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getCompositionPreview({
      "contentPieceId": "<contentPieceId>",
      "renderId": "<renderId>"
    })
  • Method: GET

    /api/v1/content/{contentPieceId}/composition/revisions

    A composition’s revisions, newest first, with what made each one. Undo is restoring one (edit_composition, restore_revision).

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for list_composition_revisions
    curl
    curl -X GET 'https://tonta.media/api/v1/content/<contentPieceId>/composition/revisions' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listCompositionRevisions({
      "contentPieceId": "<contentPieceId>"
    })
  • Method: GET

    /api/v1/content/{contentPieceId}/edit

    A finished piece as an edit you can change: its shots, voice-over, music and captions.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for get_piece_edit
    curl
    curl -X GET 'https://tonta.media/api/v1/content/<contentPieceId>/edit' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getPieceEdit({
      "contentPieceId": "<contentPieceId>"
    })
  • Method: GET

    /api/v1/content/{contentPieceId}/takes

    Every take of every shot of a piece, kept, with which one the piece plays now.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for list_shot_takes
    curl
    curl -X GET 'https://tonta.media/api/v1/content/<contentPieceId>/takes' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listShotTakes({
      "contentPieceId": "<contentPieceId>"
    })
  • Method: POST

    /api/v1/create/price-preview

    The live price of the Create settings, and what each option would change.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for preview_create_price
    curl
    curl -X POST 'https://tonta.media/api/v1/create/price-preview' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.previewCreatePrice()
  • Method: GET

    /api/v1/create/starters

    Suggested briefs to start Create from.

    Rate limit: 30 / minute

    Scope: jobs:read

    ›Request examples for list_create_starters
    curl
    curl -X GET 'https://tonta.media/api/v1/create/starters' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listCreateStarters()
  • Method: GET

    /api/v1/dubs/{jobId}/script

    Read the script of a dub planned with scriptReview: each line as said and as translated, ready to correct before any voice is paid for. Spends nothing.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for get_dub_script
    curl
    curl -X GET 'https://tonta.media/api/v1/dubs/<jobId>/script' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getDubScript({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/frame-sets

    Your frame sets (the stills a video would start on, made without the video), newest first, paged. Spends nothing.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for list_frame_sets
    curl
    curl -X GET 'https://tonta.media/api/v1/frame-sets' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listFrameSets()
  • Method: GET

    /api/v1/frame-sets/{frameSetId}

    One frame set: its frames in order with their pictures and scene notes (what each shows, the suggested motion, length, transition, camera and look). Spends nothing. To put it on a timeline: open_frame_set_as_composition (the whole set, its suggestions kept), or create_composition_from_assets with the frames you want, in your order.

    Rate limit: 120 / minute

    Scope: jobs:read

    ›Request examples for get_frame_set
    curl
    curl -X GET 'https://tonta.media/api/v1/frame-sets/<frameSetId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getFrameSet({
      "frameSetId": "<frameSetId>"
    })
  • Method: GET

    /api/v1/frame-sets/{frameSetId}/composition

    The frame set as a timeline to assemble later: each frame a still clip at its suggested length, camera move and transition, with empty voice, music, sound, overlay and text tracks. Edit it with edit_composition, preview with preview_composition, price with estimate_render and render with render_composition (its contentPieceId). Spends nothing.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for open_frame_set_as_composition
    curl
    curl -X GET 'https://tonta.media/api/v1/frame-sets/<frameSetId>/composition' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.openFrameSetAsComposition({
      "frameSetId": "<frameSetId>"
    })
  • Method: POST

    /api/v1/frame-sets/{frameSetId}/export

    A download link (valid for a few minutes) for the whole set as one zip: numbered frames in order, manifest.json with every scene note, and the timeline as OTIO and EDL for an editor. Spends nothing; ask again for a fresh link.

    Rate limit: 6 / minute

    Scope: jobs:read

    ›Request examples for export_frame_set
    curl
    curl -X POST 'https://tonta.media/api/v1/frame-sets/<frameSetId>/export' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.exportFrameSet({
      "frameSetId": "<frameSetId>"
    })
  • Method: GET

    /api/v1/graduation-offer

    Whether this workspace has earned the 'keep doing that' offer, and for which service.

    Scope: jobs:read

    ›Request examples for get_graduation_offer
    curl
    curl -X GET 'https://tonta.media/api/v1/graduation-offer' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getGraduationOffer()
  • Method: GET

    /api/v1/job-events

    A snapshot of every job still moving (and recently finished), for a live jobs list.

    Rate limit: 120 / minute

    Scope: jobs:read

    ›Request examples for read_workspace_job_events
    curl
    curl -X GET 'https://tonta.media/api/v1/job-events' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.readWorkspaceJobEvents()
  • Method: GET

    /api/v1/jobs

    Your jobs, filtered and paged newest first.

    Scope: jobs:read

    ›Request examples for list_jobs
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listJobs()
  • Method: GET

    /api/v1/jobs/{jobId}

    Read a job, its progress and what it has cost so far.

    Scope: jobs:read

    ›Request examples for get_job
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getJob({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/jobs/{jobId}/activity

    What this job is doing right now, step by step.

    Scope: jobs:read

    ›Request examples for get_job_activity
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/activity' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getJobActivity({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/jobs/{jobId}/canvas

    The stages of a job, how they depend on each other, and the takes each shot has produced so far.

    Rate limit: 240 / minute

    Scope: jobs:read

    ›Request examples for get_job_canvas
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/canvas' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getJobCanvas({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/jobs/{jobId}/credits

    How a job was actually made: every contributor (each shot’s clip or picture with its model by public name and the take kept, its opening and end stills, reference pictures, 3D scene, voice-over, music, sound effects, captions, lip sync, assembly), what each was made from (your references by name; references the brief only learned from are listed apart), the fallbacks and retries in plain words, and what each was charged, with totals that match the job’s charge. Spends nothing.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for get_job_credits
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/credits' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getJobCredits({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/jobs/{jobId}/frame-set

    The frame set a job makes: `making` (with how many stills are done) while it runs, `ready` with the set once it is made, `failed` or `canceled` (with `failure.message` in plain words) when the job stopped without making it, `none` for a job that makes no frame set. Spends nothing.

    Rate limit: 120 / minute

    Scope: jobs:read

    ›Request examples for get_job_frame_set
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/frame-set' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getJobFrameSet({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/jobs/{jobId}/motion/freeform/timing

    The beat grid and the voice-over word timings a motion item composes against: the beats (measured from the piece's music once a run has measured it; the stated tempo before), and each voice line with its words' times (estimated from the line before the narration exists). Each says which.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for get_beat_and_word_timing
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/motion/freeform/timing' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getBeatAndWordTiming({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/jobs/{jobId}/motion/pictures

    A job’s motion graphics, item by item (an overlay, an animated ending, a motion piece): where each stands and its draft and final render, each sent as a small captioned picture of its key frame. For a playable file use get_download_link with the asset id.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for get_motion_pictures
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/motion/pictures' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getMotionPictures({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/jobs/{jobId}/motion/previews

    Short-lived playback links for a job’s motion graphics: the draft preview and the final render of each item.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for get_motion_previews
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/motion/previews' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getMotionPreviews({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/jobs/{jobId}/plan-alternatives

    Other ways to make a draft plan (another model or resolution), each priced against the quote on screen. Only a model that can make every shot it takes is offered: its frame, resolution and pictures, and its length (a clip may be made at a longer length the model offers and trimmed to the shot, so a stated total length is kept exactly; choosing it re-fits the lengths and re-prices).

    Rate limit: 30 / minute

    Scope: jobs:read

    ›Request examples for list_plan_alternatives
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/plan-alternatives' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listPlanAlternatives({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/jobs/{jobId}/plan-revisions

    A job’s plan revisions, newest first, each with what changed from the one before.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for list_plan_revisions
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/plan-revisions' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listPlanRevisions({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/jobs/{jobId}/plan-revisions/compare

    What changed between two plan revisions and what each would cost now, priced by the same function as a quote (nothing is minted or held).

    Rate limit: 20 / minute

    Scope: jobs:read

    ›Request examples for compare_plan_revisions
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/plan-revisions/compare?from=1&to=1' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.comparePlanRevisions({
      "jobId": "<jobId>",
      "from": 1,
      "to": 1
    })
  • Method: GET

    /api/v1/jobs/{jobId}/production-steps

    How a multi-step production is made: each step (a still, a clip made from it, an edit of a clip, a sound), what it is made from, where it sits in the cut, its model by public name, and the take it has made so far, each sent as a small captioned picture. Spends nothing.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for get_production_steps
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/production-steps' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getProductionSteps({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/jobs/{jobId}/recast

    What a Recast job found in its clip (the scene of each shot, how hard it is, who is in it), who or what it replaces, how the tracking went, and the question it is waiting on with the picture to answer it from (a short-lived link). Spends nothing.

    Rate limit: 120 / minute

    Scope: jobs:read

    ›Request examples for get_recast_analysis
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/recast' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getRecastAnalysis({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/jobs/{jobId}/shot-outputs

    Every shot of a job as it stands: its model by public name and length, its status, how many takes it has, the take in use and the picture it opened on, plus what the job delivered (`deliverables`: each finished file by assetId, for every output kind, including a voiceover or sound that has no shots) and its motion graphics (`motion`: each item's draft render, there mid-run, and its final render, by assetId). Shots are numbered from 0 (`shotIndex` 0 is "Shot 1"); a tool that takes a `shotKey` takes this same number (as a number, its digits or "shot:N"). An assistant also receives a small picture of each. For a playable file use get_download_link with an assetId. Spends nothing.

    Rate limit: 30 / minute

    Scope: jobs:read

    ›Request examples for get_shot_outputs
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/shot-outputs' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getShotOutputs({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/jobs/{jobId}/storyboard

    The storyboard of a job’s plan: shots with their structured fields, lengths the model makes, sound, lines, transitions, scenes, cast and places, the reference pictures the piece makes for itself (planned, being made, made or not made, and why one is not made), and each shot’s opening picture once it exists, and every stated item of the brief with where the plan uses it (`requirements`). Spends nothing.

    Rate limit: 120 / minute

    Scope: jobs:read

    ›Request examples for get_storyboard
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/storyboard' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getStoryboard({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/jobs/{jobId}/treatment

    How a draft will be made: what the piece is for, its hook, beats, pacing, sound and the systems it uses, each with why in fixed words, where it came from (you asked / suggested) and whether it can be taken off. `applied`: the plan was made with it (the same card Create shows); `shadow`: recorded for comparison only. Spends nothing.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for get_treatment
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/treatment' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getTreatment({
      "jobId": "<jobId>"
    })
  • Method: POST

    /api/v1/jobs/{jobId}/wait

    Whether a job has finished, failed, needs an answer or a person, or is still working: its progress (percent, stage, time left), its files once made, and the next call to make (nextAction). Over MCP each call waits up to 20 s and returns the moment the job settles; call it again while outcome is still_running.

    Rate limit: 120 / minute

    Scope: jobs:read

    ›Request examples for wait_for_job
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/wait' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.waitForJob({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/jobs/blocks/adjust-options

    A shot's adjustable fields, their bounds, and each option's price delta.

    Rate limit: 20 / minute

    Scope: jobs:read

    ›Request examples for get_block_adjust_options
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/blocks/adjust-options?contentPieceId=%3CcontentPieceId%3E&shotKey=1' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getBlockAdjustOptions({
      "contentPieceId": "<contentPieceId>",
      "shotKey": 1
    })
  • Method: GET

    /api/v1/jobs/estimate/{quoteId}

    Read a quote: what it priced, whether it needs approval, and whether it has been used.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for get_quote
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/estimate/<quoteId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getQuote({
      "quoteId": "<quoteId>"
    })
  • Method: GET

    /api/v1/models/search

    Search the models Create can run now, each with whether it fits these settings, why not, and its price for them.

    Rate limit: 1200 / hour

    Scope: jobs:read

    ›Request examples for search_models
    curl
    curl -X GET 'https://tonta.media/api/v1/models/search' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.searchModels()
  • Method: POST

    /api/v1/motion/freeform/estimate

    What rendering a FREE-FORM composition costs: one line per stage (checks, draft preview, render, quality check; placing over the video for an overlay), the total, the render's price per second of output, its render-cost class (standard; detailed effects for particles or a heavy page; 3D effects for a 3D scene, a shader layer or a shader transition) and the render-time cap. An estimate, not a quote: attach it to a draft and resume_draft for the quote start_job spends against.

    Rate limit: 20 / minute

    Scope: jobs:read

    ›Request examples for estimate_motion
    curl
    curl -X POST 'https://tonta.media/api/v1/motion/freeform/estimate' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"composition":{"version":1,"layer":"standalone","composition":{"aspectRatio":"9:16","resolution":"480p","fps":24,"durationSeconds":1,"background":{"kind":"transparent"}},"scenes":[{"id":"<id>","label":"<label>","intent":"<intent>","start":1,"end":1}],"seed":"<seed>","program":{"language":"javascript","source":"<source>"}}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.estimateMotion({
      "composition": {
        "version": 1,
        "layer": "standalone",
        "composition": {
          "aspectRatio": "9:16",
          "resolution": "480p",
          "fps": 24,
          "durationSeconds": 1,
          "background": {
            "kind": "transparent"
          }
        },
        "scenes": [
          {
            "id": "<id>",
            "label": "<label>",
            "intent": "<intent>",
            "start": 1,
            "end": 1
          }
        ],
        "seed": "<seed>",
        "program": {
          "language": "javascript",
          "source": "<source>"
        }
      }
    })
  • Method: POST

    /api/v1/motion/freeform/measure-text

    Measure words in the fonts a motion composition renders with (the brand kit's faces, by role): their width as a share of the frame and their line breaks at a size, or the largest size that fits a box. The same metrics the sandbox and the validator use, measured on the high side, so "fits" means fits.

    Rate limit: 120 / minute

    Scope: jobs:read

    ›Request examples for measure_text
    curl
    curl -X POST 'https://tonta.media/api/v1/motion/freeform/measure-text' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"aspectRatio":"9:16","text":"<text>","font":"heading"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.measureText({
      "aspectRatio": "9:16",
      "text": "<text>",
      "font": "heading"
    })
  • Method: POST

    /api/v1/motion/freeform/model-shot

    Turn one of your own 3D models into a short video clip: a ready FREE-FORM composition that shows the model (a turntable, an orbit, a slow push-in, or a hero rise), playing one of the animation clips the model file carries, if it has any, with what rendering it costs. Nothing is spent: attach the composition to the motion item of a draft with attach_motion_composition, read the draft back with resume_draft for the quote, and start it with start_job. You may change the program before attaching it (validate_motion checks it). Moves: turntable, orbit, push_in, hero_rise. 2 to 20 s (default 6). Background "transparent" makes an overlay. Priced as 3D effects.

    Rate limit: 20 / minute

    Scope: jobs:read

    ›Request examples for get_model_shot_composition
    curl
    curl -X POST 'https://tonta.media/api/v1/motion/freeform/model-shot' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"modelAssetId":"<modelAssetId>","move":"turntable","aspectRatio":"9:16"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getModelShotComposition({
      "modelAssetId": "<modelAssetId>",
      "move": "turntable",
      "aspectRatio": "9:16"
    })
  • Method: GET

    /api/v1/motion/freeform/patterns

    The vetted FREE-FORM motion patterns (kinetic type, logo sting, lower third, bar chart, line chart, product on a 3D plane, map route, split screen, countdown, quote card, UI walkthrough, shader backdrop, particles, words on the voice-over, a 3D hero): search by words or category for the list, or ask by id for one worked program to adapt, returned as `{ language, source }`: the shape a composition's `program` takes, so it goes in as is. Each says when to use it, the references it needs and its render-cost class.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for lookup_motion_pattern
    curl
    curl -X GET 'https://tonta.media/api/v1/motion/freeform/patterns' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.lookupMotionPattern()
  • Method: POST

    /api/v1/motion/freeform/preview

    Render up to 4 low-resolution stills (360px on the long edge) of a FREE-FORM composition at the times you choose, through the same renderer as the final render, to see what the program draws. No charge (it runs on Tonta's own renderer and is recorded at our cost), limited to 20 an hour. The composition is validated first; an invalid one answers its errors and no frames. A long program with clips can take a few minutes: if the call times out, call it again with the same composition and times, and it picks up the same preview (or returns it once made) rather than starting over.

    Rate limit: 20 / hour

    Scope: jobs:read

    ›Request examples for preview_motion_frames
    curl
    curl -X POST 'https://tonta.media/api/v1/motion/freeform/preview' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"composition":{"version":1,"layer":"standalone","composition":{"aspectRatio":"9:16","resolution":"480p","fps":24,"durationSeconds":1,"background":{"kind":"transparent"}},"scenes":[{"id":"<id>","label":"<label>","intent":"<intent>","start":1,"end":1}],"seed":"<seed>","program":{"language":"javascript","source":"<source>"}},"times":[1]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.previewMotionFrames({
      "composition": {
        "version": 1,
        "layer": "standalone",
        "composition": {
          "aspectRatio": "9:16",
          "resolution": "480p",
          "fps": 24,
          "durationSeconds": 1,
          "background": {
            "kind": "transparent"
          }
        },
        "scenes": [
          {
            "id": "<id>",
            "label": "<label>",
            "intent": "<intent>",
            "start": 1,
            "end": 1
          }
        ],
        "seed": "<seed>",
        "program": {
          "language": "javascript",
          "source": "<source>"
        }
      },
      "times": [
        1
      ]
    })
  • Method: POST

    /api/v1/motion/freeform/skeleton

    Start a FREE-FORM motion-graphics composition: a complete composition to fill (frame, scenes on the beat or the voice lines, safe area, references, a seed, and a JavaScript program that already builds), with the runtime reference (every tonta.* helper and its limits), the vetted shader transitions and the beat and word timing. Use free-form for bespoke kinetic type, logo stings, data reveals, a product on a 3D plane, shader or particle backgrounds, a walkthrough over your own screenshots, or motion design over and around your own clips (declare a video asset or reference and play it with tonta.video); use the block-built motion of create for standard titles, lower thirds and end cards. Then: lookup_motion_pattern, validate_motion, preview_motion_frames, estimate_motion, attach_motion_composition. Limits: up to 60s, 480p/720p/1080p, 24 or 30 fps, 160 nodes, 1200 particles, one 3D scene of 24 objects, 2 shader layers; the program builds in 2s and 48 MiB with no network, files, clock, eval or modules; the priced render may not exceed 420s of rendering. Clips play as layers (tonta.video: up to 4, trimmed with in/out and from, time-mapped with speed or a rate ramp, muted, priced as footage); a picture or clip shows only once it exists: generate it first (it lands in the library), then declare it as a reference by its asset id. Lottie: 2 documents of 200k characters and 3600 frames, no expressions, images only as your references. Sync: tonta.beat/bar/word/line times are re-resolved to the MEASURED music and voice at render (within one frame); the quote binds the program, not the seconds.

    Rate limit: 30 / minute

    Scope: jobs:read

    ›Request examples for get_motion_skeleton
    curl
    curl -X POST 'https://tonta.media/api/v1/motion/freeform/skeleton' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getMotionSkeleton()
  • Method: POST

    /api/v1/motion/freeform/validate

    Check a FREE-FORM motion composition: its program runs once in Tonta's sandbox and every result is checked (shape, text re-measured and inside the safe area, references yours, the render-time cap). Answers ok, or exact errors, each with a code, the program line, the node and a fix. Your program is treated as untrusted code: no network, files, clock, eval or modules. Spends nothing. Limits: up to 60s, 480p/720p/1080p, 24 or 30 fps, 160 nodes, 1200 particles, one 3D scene of 24 objects, 2 shader layers; the program builds in 2s and 48 MiB with no network, files, clock, eval or modules; the priced render may not exceed 420s of rendering. Clips play as layers (tonta.video: up to 4, trimmed with in/out and from, time-mapped with speed or a rate ramp, muted, priced as footage); a picture or clip shows only once it exists: generate it first (it lands in the library), then declare it as a reference by its asset id. Lottie: 2 documents of 200k characters and 3600 frames, no expressions, images only as your references. Sync: tonta.beat/bar/word/line times are re-resolved to the MEASURED music and voice at render (within one frame); the quote binds the program, not the seconds.

    Rate limit: 20 / minute

    Scope: jobs:read

    ›Request examples for validate_motion
    curl
    curl -X POST 'https://tonta.media/api/v1/motion/freeform/validate' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"composition":{"version":1,"layer":"standalone","composition":{"aspectRatio":"9:16","resolution":"480p","fps":24,"durationSeconds":1,"background":{"kind":"transparent"}},"scenes":[{"id":"<id>","label":"<label>","intent":"<intent>","start":1,"end":1}],"seed":"<seed>","program":{"language":"javascript","source":"<source>"}}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.validateMotion({
      "composition": {
        "version": 1,
        "layer": "standalone",
        "composition": {
          "aspectRatio": "9:16",
          "resolution": "480p",
          "fps": 24,
          "durationSeconds": 1,
          "background": {
            "kind": "transparent"
          }
        },
        "scenes": [
          {
            "id": "<id>",
            "label": "<label>",
            "intent": "<intent>",
            "start": 1,
            "end": 1
          }
        ],
        "seed": "<seed>",
        "program": {
          "language": "javascript",
          "source": "<source>"
        }
      }
    })
  • Method: GET

    /api/v1/parts

    Your part runs, newest first, paged. Started ones by default.

    Scope: jobs:read

    ›Request examples for list_parts
    curl
    curl -X GET 'https://tonta.media/api/v1/parts' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listParts()
  • Method: GET

    /api/v1/parts/{jobId}

    Read a part run: each item with its state, price, charge and asset. Progress also arrives as the job’s own events. Its pictures go on a timeline, with nothing generated, through create_composition_from_assets (their assetIds, in your order).

    Scope: jobs:read

    ›Request examples for get_part
    curl
    curl -X GET 'https://tonta.media/api/v1/parts/<jobId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getPart({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/plan-runs/{planRunId}

    Read a background plan: what it is doing now, then the plan, a question, or why it could not be made, with the next call to make (nextAction). Over MCP each call waits up to 20 s and returns the moment the plan is final.

    Scope: jobs:read

    ›Request examples for get_plan_run
    curl
    curl -X GET 'https://tonta.media/api/v1/plan-runs/<planRunId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getPlanRun({
      "planRunId": "<planRunId>"
    })
  • Method: GET

    /api/v1/presets

    The presets this workspace may choose from, and what each can do.

    Scope: jobs:read

    ›Request examples for list_presets
    curl
    curl -X GET 'https://tonta.media/api/v1/presets' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listPresets()
  • Method: GET

    /api/v1/questions/{elicitationId}/options

    Search every option an open question accepts.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for list_elicitation_options
    curl
    curl -X GET 'https://tonta.media/api/v1/questions/<elicitationId>/options' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listElicitationOptions({
      "elicitationId": "<elicitationId>"
    })
  • Method: POST

    /api/v1/recast/plan

    Plan a Recast before paying: the shots, who or what is replaced, the opening pictures, masks and quality checks, the steps that are priced, or the question that must be answered first. Spends nothing; start it with create (settings.video.subMode "recast"). The person starting it must confirm consent for anyone shown, which an agent cannot do for them.

    Rate limit: 20 / minute

    Scope: jobs:read

    ›Request examples for plan_recast
    curl
    curl -X POST 'https://tonta.media/api/v1/recast/plan' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"recast":{"mode":"character","referenceIds":["<referenceIds>"]}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.planRecast({
      "recast": {
        "mode": "character",
        "referenceIds": [
          "<referenceIds>"
        ]
      }
    })
  • Method: GET

    /api/v1/review

    Pieces waiting for your decision.

    Scope: jobs:read

    ›Request examples for list_review_queue
    curl
    curl -X GET 'https://tonta.media/api/v1/review' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listReviewQueue()
  • Method: GET

    /api/v1/services

    Which services this workspace can plan and submit right now.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for list_services
    curl
    curl -X GET 'https://tonta.media/api/v1/services' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listServices()
  • Method: GET

    /api/v1/sessions

    Your conversations with the planning agent, newest-active first.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for list_sessions
    curl
    curl -X GET 'https://tonta.media/api/v1/sessions' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listSessions()
  • Method: GET

    /api/v1/sessions/{sessionId}

    Read a conversation: its recent turns and rolling summary.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for get_session
    curl
    curl -X GET 'https://tonta.media/api/v1/sessions/<sessionId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getSession({
      "sessionId": "<sessionId>"
    })
  • Method: GET

    /api/v1/sessions/{sessionId}/turns

    Read a conversation's turns appended after a cursor.

    Rate limit: 120 / minute

    Scope: jobs:read

    ›Request examples for list_session_turns_since
    curl
    curl -X GET 'https://tonta.media/api/v1/sessions/<sessionId>/turns' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listSessionTurnsSince({
      "sessionId": "<sessionId>"
    })
  • Method: GET

    /api/v1/showcase/{showcaseId}/create-prefill

    Start Create from a showcase item.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for get_showcase_prefill
    curl
    curl -X GET 'https://tonta.media/api/v1/showcase/<showcaseId>/create-prefill' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getShowcasePrefill({
      "showcaseId": "<showcaseId>"
    })
  • Method: GET

    /api/v1/voice-consents/{recordingId}

    Read a recorded consent: the words to read while it is open, then whether it was confirmed, refused or is being checked by a person.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for get_voice_consent_recording
    curl
    curl -X GET 'https://tonta.media/api/v1/voice-consents/<recordingId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getVoiceConsentRecording({
      "recordingId": "<recordingId>"
    })
  • Method: GET

    /api/v1/voice-designs/{voiceDesignId}

    Read a voice design: its quote, whether it is being made, and the voice once it exists.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for get_voice_design
    curl
    curl -X GET 'https://tonta.media/api/v1/voice-designs/<voiceDesignId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getVoiceDesign({
      "voiceDesignId": "<voiceDesignId>"
    })
  • Method: GET

    /api/v1/voice-library

    Every voice you can speak in: the stock voices, the voices cloned from your own recordings and the voices you designed, each with whether it is ready and a preview to play. Spends nothing.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for list_voice_library
    curl
    curl -X GET 'https://tonta.media/api/v1/voice-library' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listVoiceLibrary()
  • Method: GET

    /api/v1/voice-library/{referenceId}/preview

    Play one of your own voices before choosing it: a designed voice’s preview, or the recording a cloned voice comes from, as inline audio (base64). Spends nothing.

    Rate limit: 30 / minute

    Scope: jobs:read

    ›Request examples for get_voice_preview
    curl
    curl -X GET 'https://tonta.media/api/v1/voice-library/<referenceId>/preview' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getVoicePreview({
      "referenceId": "<referenceId>"
    })
  • Method: GET

    /api/v1/workspace/plan-review

    Whether this workspace always reviews the plan before a Create request runs.

    Rate limit: 60 / minute

    Scope: jobs:read

    ›Request examples for get_workspace_plan_review
    curl
    curl -X GET 'https://tonta.media/api/v1/workspace/plan-review' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getWorkspacePlanReview()
  • Method: POST

    /api/v1/ads/batch

    Quote N ad variants of one offering (angles x hook lines x shapes) as ONE job: one quote that is the sum of its items, one hold; a failed item is refunded. Spends nothing: start it with start_job.

    Rate limit: 10 / minute

    Scope: jobs:writeidempotent

    ›Request examples for generate_ad_batch
    curl
    curl -X POST 'https://tonta.media/api/v1/ads/batch' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)" \
      -H 'Content-Type: application/json' \
      -d '{"offeringId":"<offeringId>","angles":["unboxing"],"aspectRatios":["9:16"]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.generateAdBatch({
      "offeringId": "<offeringId>",
      "angles": [
        "unboxing"
      ],
      "aspectRatios": [
        "9:16"
      ],
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: POST

    /api/v1/ads/batches/{jobId}/variants/{index}/piece

    Make one finished ad variant publishable: returns the piece its file is published as (made once per file; a repeat returns the same one). Publish it with get_publish_context and schedule_post_multi. Spends nothing.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for make_ad_variant_piece
    curl
    curl -X POST 'https://tonta.media/api/v1/ads/batches/<jobId>/variants/<index>/piece' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.makeAdVariantPiece({
      "jobId": "<jobId>",
      "index": 1
    })
  • Method: POST

    /api/v1/ads/batches/{jobId}/winner

    Mark one finished variant of an ad batch as the winner (one per batch), or clear it with null. A variant with no finished file is refused. Spends nothing.

    Scope: jobs:write

    ›Request examples for set_ad_winner
    curl
    curl -X POST 'https://tonta.media/api/v1/ads/batches/<jobId>/winner' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"index":1}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.setAdWinner({
      "jobId": "<jobId>",
      "index": 1
    })
  • Method: POST

    /api/v1/ads/hook-suggestions

    Suggest short opening lines for ads of one offering, for you to pick. Never applied by itself. Charged for what the request costs, at most the price get_ad_hook_price showed, which you send back.

    Rate limit: 6 / minute

    Scope: jobs:writeidempotent

    ›Request examples for suggest_ad_hooks
    curl
    curl -X POST 'https://tonta.media/api/v1/ads/hook-suggestions' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)" \
      -H 'Content-Type: application/json' \
      -d '{"offeringId":"<offeringId>","maxChargeMicroUsd":"1000000"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.suggestAdHooks({
      "offeringId": "<offeringId>",
      "maxChargeMicroUsd": "1000000",
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: POST

    /api/v1/assets/{assetId}/operations

    Quote one edit of one of your files: a new file, with the original kept. Spends nothing: start it with start_job.

    Rate limit: 30 / minute

    Scope: jobs:writeidempotent

    ›Request examples for estimate_asset_operation
    curl
    curl -X POST 'https://tonta.media/api/v1/assets/<assetId>/operations' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)" \
      -H 'Content-Type: application/json' \
      -d '{"operation":"upscale_image"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.estimateAssetOperation({
      "assetId": "<assetId>",
      "operation": "upscale_image",
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: POST

    /api/v1/compositions/from-assets

    Put pictures (and clips) already in your library or frame sets on a new timeline, in the order you give, with no video model: each picture a still clip held for its length with a camera move (push_in, ken_burns, pan...), joined by an optional transition (one for every cut, or each item’s own), with empty voice, music, sound, overlay and text tracks. Nothing is generated or charged here. Then edit_composition adds words on screen, a voice-over and music, preview_composition checks it, estimate_render prices the render and render_composition spends that quote. Send idempotencyKey so a retry returns the same piece.

    Rate limit: 20 / minute

    Scope: jobs:writeidempotent

    ›Request examples for create_composition_from_assets
    curl
    curl -X POST 'https://tonta.media/api/v1/compositions/from-assets' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)" \
      -H 'Content-Type: application/json' \
      -d '{"items":[{"assetId":"<assetId>"}]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.createCompositionFromAssets({
      "items": [
        {
          "assetId": "<assetId>"
        }
      ],
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: PATCH

    /api/v1/content/{contentPieceId}/captions

    Edit a piece's captions and re-render them. Free.

    Rate limit: 30 / hour

    Scope: jobs:write

    ›Request examples for update_caption_track
    curl
    curl -X PATCH 'https://tonta.media/api/v1/content/<contentPieceId>/captions' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"baseVersion":1}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.updateCaptionTrack({
      "contentPieceId": "<contentPieceId>",
      "baseVersion": 1
    })
  • Method: POST

    /api/v1/content/{contentPieceId}/composition/discard

    Discard every timeline edit saved since the piece’s last render (or since the piece itself, when it was never rendered): the timeline returns to that state as one new revision. The rendered video and its history are not touched, files the edits added stay in the library, and the discarded revisions stay in the history (restore_revision brings them back). Send the revision you saw as `expectedRevision`: a change saved meanwhile is a `conflict` carrying `details.currentRevision` (read it again and decide). Safe to retry: a repeat answers `replayed`. Nothing to discard answers `discarded: false`. Spends nothing.

    Rate limit: 20 / minute

    Scope: jobs:write

    ›Request examples for discard_composition_edits
    curl
    curl -X POST 'https://tonta.media/api/v1/content/<contentPieceId>/composition/discard' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"expectedRevision":1}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.discardCompositionEdits({
      "contentPieceId": "<contentPieceId>",
      "expectedRevision": 1
    })
  • Method: POST

    /api/v1/content/{contentPieceId}/composition/edits

    Change a piece’s timeline: add, remove, move, trim, split or duplicate clips (video, overlay or sound); speed and speed ramps; freeze a frame (freeze_frame, set_freeze) and play a clip or a stretch backwards (set_reverse, reverse_range); masks (set_mask: rect, ellipse, rounded_rect or a freeform path, feathered, inverted, keyframable); keyframes placed on each clip for zoom, position, rotation, opacity, edge crop, mask shape and sound level (set_property at a moment adds or updates the keyframe there; remove_keyframe, move_keyframe, set_keyframe_easing with linear, ease, hold or bezier); take a video’s sound out as its own linked clip (detach_audio, unlink_audio); overlays stacked by track order (move_track), anchored over a stretch of a clip (add_overlay_over_clip, anchor_overlay), blended, and picture in picture (set_picture_in_picture); looks, effects, framing and still moves; transitions in and out; text; tracks and sound clips with levels and fades; captions; the mix and loudness; markers; the trim and extra frames; restore a revision. Send one change as `edit` or up to 50 as `edits`, applied in order as ONE revision against `expectedRevision`, all or nothing. Every change is saved as it is made, so this is also how to continue a timeline edit left unfinished (find those with list_compositions_in_progress, read the latest with get_composition). A `conflict` with reason `composition_changed` carries `details.currentRevision`: read that revision and send the change again against it. A refused change is named (`details.editIndex`) with a closed `reason` and `options`, each priced. Spends nothing: returns the price before and after; estimate_render quotes it.

    Rate limit: 60 / minute

    Scope: jobs:write

    ›Request examples for edit_composition
    curl
    curl -X POST 'https://tonta.media/api/v1/content/<contentPieceId>/composition/edits' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"expectedRevision":1}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.editComposition({
      "contentPieceId": "<contentPieceId>",
      "expectedRevision": 1
    })
  • Method: POST

    /api/v1/content/{contentPieceId}/composition/frames

    Look at a timeline at given moments: the frames of one revision at up to 12 times on the piece’s clock (milliseconds), exactly as the render draws them (small, watermarked), each with a short-lived link. Use it after edit_composition to check an edit (a freeze, a reverse, a mask, keyframed motion, overlays and blends) and correct it. The first look at a revision makes its small preview, so the answer may be `rendering` with `retryAfterMs`: ask again then. Never charged; it uses the day’s preview allowance once per revision. Links expire at expiresAt: look now, never store them.

    Rate limit: 60 / minute

    Scope: jobs:write

    ›Request examples for get_composition_frames
    curl
    curl -X POST 'https://tonta.media/api/v1/content/<contentPieceId>/composition/frames' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"revision":1,"timesMs":[1]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getCompositionFrames({
      "contentPieceId": "<contentPieceId>",
      "revision": 1,
      "timesMs": [
        1
      ]
    })
  • Method: POST

    /api/v1/content/{contentPieceId}/composition/preview

    A small, fast preview of one revision of a composition (360p, up to three minutes), to check timing and moves before rendering. Never charged; a daily allowance of preview time applies. A preview cannot be published or downloaded.

    Rate limit: 10 / minute

    Scope: jobs:write

    ›Request examples for preview_composition
    curl
    curl -X POST 'https://tonta.media/api/v1/content/<contentPieceId>/composition/preview' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"revision":1}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.previewComposition({
      "contentPieceId": "<contentPieceId>",
      "revision": 1
    })
  • Method: POST

    /api/v1/content/{contentPieceId}/composition/render

    Spend a render estimate and put the piece together from that revision of its composition, as a new version of the piece. Nothing already published changes; the new version publishes only once adopted.

    Rate limit: 30 / hour

    Scope: jobs:writeidempotentneeds a quote

    ›Request examples for render_composition
    curl
    curl -X POST 'https://tonta.media/api/v1/content/<contentPieceId>/composition/render' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)" \
      -H 'Content-Type: application/json' \
      -d '{"quoteId":"<quoteId>","revision":1}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.renderComposition({
      "quoteId": "<quoteId>",
      "contentPieceId": "<contentPieceId>",
      "revision": 1,
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: POST

    /api/v1/content/{contentPieceId}/composition/render/estimate

    Check a revision of a composition and price rendering it (only the new work: changed speech, a new soundtrack, our own rendering time). Returns a single-use quote bound to exactly that revision on exactly that piece; render_composition spends it.

    Rate limit: 40 / minute

    Scope: jobs:write

    ›Request examples for estimate_render
    curl
    curl -X POST 'https://tonta.media/api/v1/content/<contentPieceId>/composition/render/estimate' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"revision":1}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.estimateRender({
      "contentPieceId": "<contentPieceId>",
      "revision": 1
    })
  • Method: POST

    /api/v1/content/{contentPieceId}/edit/estimate

    Check an edit and price only the new work in it.

    Rate limit: 40 / minute

    Scope: jobs:write

    ›Request examples for estimate_reassembly
    curl
    curl -X POST 'https://tonta.media/api/v1/content/<contentPieceId>/edit/estimate' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"baseVersion":"<baseVersion>","edl":{"version":1,"aspect":"9:16","segments":[{"id":"<id>","source":{},"rotate":0,"flipH":false,"flipV":false,"fit":"crop","nativeAudio":"keep","transitionIn":{}}],"narration":{"mode":"keep"},"music":{"mode":"keep"},"levels":{"narrationDb":1,"musicDb":1,"duckMusic":false},"captions":{"mode":"keep"},"pieceTrim":{"startMs":1,"endMs":1},"extraAspects":["9:16"]}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.estimateReassembly({
      "contentPieceId": "<contentPieceId>",
      "baseVersion": "<baseVersion>",
      "edl": {
        "version": 1,
        "aspect": "9:16",
        "segments": [
          {
            "id": "<id>",
            "source": {},
            "rotate": 0,
            "flipH": false,
            "flipV": false,
            "fit": "crop",
            "nativeAudio": "keep",
            "transitionIn": {}
          }
        ],
        "narration": {
          "mode": "keep"
        },
        "music": {
          "mode": "keep"
        },
        "levels": {
          "narrationDb": 1,
          "musicDb": 1,
          "duckMusic": false
        },
        "captions": {
          "mode": "keep"
        },
        "pieceTrim": {
          "startMs": 1,
          "endMs": 1
        },
        "extraAspects": [
          "9:16"
        ]
      }
    })
  • Method: POST

    /api/v1/content/{contentPieceId}/edit/start

    Spend an edit estimate and put the piece together again as a new version.

    Rate limit: 30 / hour

    Scope: jobs:writeidempotentneeds a quote

    ›Request examples for start_reassembly
    curl
    curl -X POST 'https://tonta.media/api/v1/content/<contentPieceId>/edit/start' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)" \
      -H 'Content-Type: application/json' \
      -d '{"quoteId":"<quoteId>","baseVersion":"<baseVersion>","edl":{"version":1,"aspect":"9:16","segments":[{"id":"<id>","source":{},"rotate":0,"flipH":false,"flipV":false,"fit":"crop","nativeAudio":"keep","transitionIn":{}}],"narration":{"mode":"keep"},"music":{"mode":"keep"},"levels":{"narrationDb":1,"musicDb":1,"duckMusic":false},"captions":{"mode":"keep"},"pieceTrim":{"startMs":1,"endMs":1},"extraAspects":["9:16"]}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.startReassembly({
      "quoteId": "<quoteId>",
      "contentPieceId": "<contentPieceId>",
      "baseVersion": "<baseVersion>",
      "edl": {
        "version": 1,
        "aspect": "9:16",
        "segments": [
          {
            "id": "<id>",
            "source": {},
            "rotate": 0,
            "flipH": false,
            "flipV": false,
            "fit": "crop",
            "nativeAudio": "keep",
            "transitionIn": {}
          }
        ],
        "narration": {
          "mode": "keep"
        },
        "music": {
          "mode": "keep"
        },
        "levels": {
          "narrationDb": 1,
          "musicDb": 1,
          "duckMusic": false
        },
        "captions": {
          "mode": "keep"
        },
        "pieceTrim": {
          "startMs": 1,
          "endMs": 1
        },
        "extraAspects": [
          "9:16"
        ]
      },
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: POST

    /api/v1/content/{contentPieceId}/shots/{shotKey}/brief-estimate

    Price a regeneration of one shot from your own brief, bound to the exact text that will be used. Name the piece (contentPieceId, not the job) and the shot (shotKey, counted from 0 like get_shot_outputs’ shotIndex), and send back prepare_shot_regeneration’s prompt and brief. Spends nothing; submit_block_regeneration redeems the quote.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for estimate_shot_regeneration
    curl
    curl -X POST 'https://tonta.media/api/v1/content/<contentPieceId>/shots/<shotKey>/brief-estimate' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"words":"<words>","prompt":"<prompt>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.estimateShotRegeneration({
      "words": "<words>",
      "prompt": "<prompt>",
      "contentPieceId": "<contentPieceId>",
      "shotKey": 1
    })
  • Method: POST

    /api/v1/content/{contentPieceId}/shots/{shotKey}/brief-preview

    Turn your own description of a shot into the text it will be asked for, before anything is priced.

    Rate limit: 20 / minute

    Scope: jobs:write

    ›Request examples for prepare_shot_regeneration
    curl
    curl -X POST 'https://tonta.media/api/v1/content/<contentPieceId>/shots/<shotKey>/brief-preview' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"words":"<words>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.prepareShotRegeneration({
      "contentPieceId": "<contentPieceId>",
      "shotKey": 1,
      "words": "<words>"
    })
  • Method: POST

    /api/v1/content/{contentPieceId}/takes/choose

    Build the edit that puts a chosen take in its shot. Nothing is changed or charged: price it with estimate_reassembly and start it with start_reassembly.

    Rate limit: 60 / minute

    Scope: jobs:write

    ›Request examples for plan_take_choice
    curl
    curl -X POST 'https://tonta.media/api/v1/content/<contentPieceId>/takes/choose' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"attemptId":"<attemptId>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.planTakeChoice({
      "contentPieceId": "<contentPieceId>",
      "attemptId": "<attemptId>"
    })
  • Method: POST

    /api/v1/content/attempts/{attemptId}/curate

    Pin or reject a regenerated version — never spends, never changes review status.

    Rate limit: 60 / minute

    Scope: jobs:write

    ›Request examples for curate_block_attempt
    curl
    curl -X POST 'https://tonta.media/api/v1/content/attempts/<attemptId>/curate' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"decision":"pin"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.curateBlockAttempt({
      "attemptId": "<attemptId>",
      "decision": "pin"
    })
  • Method: POST

    /api/v1/create

    Describe what to make. Classifies, fills the settings, and returns a question, a priced quote, or the started job. Making the plan is charged for what it actually uses (usually a few cents; a small hold is reserved first and the rest released), apart from the quote and whether or not the piece is started; the quote states it as `planningChargedMicroUsd`. A motion piece written as code plans for more: writing it is charged at its actual cost with no margin, never above the bound `preview_create_price` gives as `planning.motionPieceUpToMicroUsd`. A brief may be long (a whole script, a shot list, or how to make it) and is never cut; a long one plans for a little more, and the quote says so. A brief or script that is a file goes in `briefDocumentId`. A stated length (`settings.targetDurationSeconds`, up to 600 s) is met exactly: each clip is made at a length its model offers and trimmed to its beat (`cutSeconds` on the plan), and a long piece gets as many shots as it needs. The plan lists every stated item of the brief in `requirements`, with where it is used and anything not in the plan yet.

    Rate limit: 20 / minute

    Scope: jobs:writeidempotent

    ›Request examples for create
    curl
    curl -X POST 'https://tonta.media/api/v1/create' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.create({
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: PATCH

    /api/v1/dubs/{jobId}/script

    Correct lines of a dub script before the voice step: send the revision you read and each changed line. Saving the machine text again undoes an edit; an empty line is not spoken. Free; the voice is priced afterwards on the final text.

    Rate limit: 60 / minute

    Scope: jobs:write

    ›Request examples for edit_dub_script
    curl
    curl -X PATCH 'https://tonta.media/api/v1/dubs/<jobId>/script' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"revision":1,"edits":[{"locale":"<locale>","segmentIndex":1,"text":"<text>"}]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.editDubScript({
      "jobId": "<jobId>",
      "revision": 1,
      "edits": [
        {
          "locale": "<locale>",
          "segmentIndex": 1,
          "text": "<text>"
        }
      ]
    })
  • Method: DELETE

    /api/v1/frame-sets/{frameSetId}/frames/{frameId}

    Take one frame out of a frame set; the rest keep their order. Its picture stays in your library. Free.

    Rate limit: 60 / minute

    Scope: jobs:write

    ›Request examples for remove_frame
    curl
    curl -X DELETE 'https://tonta.media/api/v1/frame-sets/<frameSetId>/frames/<frameId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.removeFrame({
      "frameSetId": "<frameSetId>",
      "frameId": "<frameId>"
    })
  • Method: POST

    /api/v1/frame-sets/{frameSetId}/frames/{frameId}/regenerate/estimate

    Quote remaking ONE frame as a picture part: `redraw` makes a new picture from the frame’s note (or your words), `edit` changes the current picture by your instruction and keeps its look. Spends nothing: start it with start_job, then swap it in with replace_frame.

    Rate limit: 20 / minute

    Scope: jobs:write

    ›Request examples for estimate_frame_regeneration
    curl
    curl -X POST 'https://tonta.media/api/v1/frame-sets/<frameSetId>/frames/<frameId>/regenerate/estimate' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.estimateFrameRegeneration({
      "frameSetId": "<frameSetId>",
      "frameId": "<frameId>"
    })
  • Method: POST

    /api/v1/frame-sets/{frameSetId}/frames/{frameId}/replace

    Swap a frame’s picture for a finished picture part (the job `estimate_frame_regeneration` quoted and `start_job` started). Free, and undone by swapping back. A picture still being checked, or held, cannot be used.

    Rate limit: 60 / minute

    Scope: jobs:write

    ›Request examples for replace_frame
    curl
    curl -X POST 'https://tonta.media/api/v1/frame-sets/<frameSetId>/frames/<frameId>/replace' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"partJobId":"<partJobId>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.replaceFrame({
      "frameSetId": "<frameSetId>",
      "frameId": "<frameId>",
      "partJobId": "<partJobId>"
    })
  • Method: POST

    /api/v1/frame-sets/{frameSetId}/order

    Put a frame set in a new order: send every frame id exactly once, in the order you want. Free; changes only the set.

    Rate limit: 60 / minute

    Scope: jobs:write

    ›Request examples for reorder_frame_set
    curl
    curl -X POST 'https://tonta.media/api/v1/frame-sets/<frameSetId>/order' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"frameIds":["<frameIds>"]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.reorderFrameSet({
      "frameSetId": "<frameSetId>",
      "frameIds": [
        "<frameIds>"
      ]
    })
  • Method: POST

    /api/v1/frame-sets/{frameSetId}/video/estimate

    Quote a photo video made from this frame set, each frame its own moving scene in the set’s order, through the ordinary Create estimate. Change a scene’s motion, length or transition first with `changes`. Spends nothing: start it with start_job and the quote.

    Rate limit: 10 / minute

    Scope: jobs:write

    ›Request examples for estimate_frame_set_video
    curl
    curl -X POST 'https://tonta.media/api/v1/frame-sets/<frameSetId>/video/estimate' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.estimateFrameSetVideo({
      "frameSetId": "<frameSetId>"
    })
  • Method: POST

    /api/v1/jobs

    Submit a quoted job for generation.

    Rate limit: 20 / minute

    Scope: jobs:writeidempotentneeds a quote

    ›Request examples for submit_job
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)" \
      -H 'Content-Type: application/json' \
      -d '{"quoteId":"<quoteId>","service":"publishing"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.submitJob({
      "quoteId": "<quoteId>",
      "service": "publishing",
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: POST

    /api/v1/jobs/{jobId}/cancel

    Cancel a job and release whatever credit it has not spent.

    Scope: jobs:write

    ›Request examples for cancel_job
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/cancel' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.cancelJob({
      "jobId": "<jobId>"
    })
  • Method: POST

    /api/v1/jobs/{jobId}/follow-on/estimate

    Price the follow-on stage of a finished composed job (the dub into the languages it was planned with) from the piece as it was actually made, and return a single-use quote for it. Start it with start_follow_on and this quoteId; nothing is spent here.

    Rate limit: 20 / minute

    Scope: jobs:write

    ›Request examples for estimate_follow_on
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/follow-on/estimate' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.estimateFollowOn({
      "jobId": "<jobId>"
    })
  • Method: POST

    /api/v1/jobs/{jobId}/follow-on/start

    Start the dubbing stage of a finished composed job. An API key or assistant first prices it with estimate_follow_on and passes that quoteId, which this spends exactly once; a person on the web may start it from the credit reserved with the job.

    Rate limit: 20 / minute

    Scope: jobs:writeneeds a quote

    ›Request examples for start_follow_on
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/follow-on/start' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.startFollowOn({
      "jobId": "<jobId>"
    })
  • Method: POST

    /api/v1/jobs/{jobId}/layers

    Replace a draft's layers: attached pictures shown in a corner (picture-in-picture) over a run of shots, and words on screen over a run of shots, in the listed corners, sizes, positions, styles and animations. Send the whole set; empty lists remove them all. Only pictures this draft offered for insets, and only shots the plan has. Spends nothing; returns the layers and the draft's price before and after. Start with the draft's next quote (resume_draft, then start_job).

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for edit_plan_layers
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/layers' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"insets":[{"referenceId":"<referenceId>","fromShot":1,"toShot":1,"corner":"top_left","size":"small"}],"texts":[{"text":"<text>","fromShot":1,"toShot":1,"position":"top","style":"card"}]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.editPlanLayers({
      "jobId": "<jobId>",
      "insets": [
        {
          "referenceId": "<referenceId>",
          "fromShot": 1,
          "toShot": 1,
          "corner": "top_left",
          "size": "small"
        }
      ],
      "texts": [
        {
          "text": "<text>",
          "fromShot": 1,
          "toShot": 1,
          "position": "top",
          "style": "card"
        }
      ]
    })
  • Method: POST

    /api/v1/jobs/{jobId}/motion/export

    Export a finished transparent motion overlay (titles, lower thirds, stickers over a shot) for use elsewhere: as WebM VP9 with alpha (browsers, web players, most editors) or a zipped PNG sequence with alpha (any editor). Returns the new file as an asset of the job; fetch it with get_download_link. No charge; asking again returns the same file.

    Rate limit: 20 / hour

    Scope: jobs:write

    ›Request examples for export_motion_overlay
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/motion/export' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"n":1,"format":"webm_alpha"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.exportMotionOverlay({
      "jobId": "<jobId>",
      "n": 1,
      "format": "webm_alpha"
    })
  • Method: POST

    /api/v1/jobs/{jobId}/motion/freeform

    Put a FREE-FORM composition on one motion item of a DRAFT plan, in place of its block-built motion (its sound, placement and length stay). It is validated again here and nothing is written on any error. Spends nothing: read the draft back with resume_draft for the new quote, and start it with start_job. The quote binds to the exact program and graph that were checked.

    Rate limit: 20 / minute

    Scope: jobs:write

    ›Request examples for attach_motion_composition
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/motion/freeform' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"n":1,"composition":{"version":1,"layer":"standalone","composition":{"aspectRatio":"9:16","resolution":"480p","fps":24,"durationSeconds":1,"background":{"kind":"transparent"}},"scenes":[{"id":"<id>","label":"<label>","intent":"<intent>","start":1,"end":1}],"seed":"<seed>","program":{"language":"javascript","source":"<source>"}}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.attachMotionComposition({
      "jobId": "<jobId>",
      "n": 1,
      "composition": {
        "version": 1,
        "layer": "standalone",
        "composition": {
          "aspectRatio": "9:16",
          "resolution": "480p",
          "fps": 24,
          "durationSeconds": 1,
          "background": {
            "kind": "transparent"
          }
        },
        "scenes": [
          {
            "id": "<id>",
            "label": "<label>",
            "intent": "<intent>",
            "start": 1,
            "end": 1
          }
        ],
        "seed": "<seed>",
        "program": {
          "language": "javascript",
          "source": "<source>"
        }
      }
    })
  • Method: POST

    /api/v1/jobs/{jobId}/motion/freeform/revise

    Revise the motion graphics of a FINISHED or FAILED motion piece without planning it again: send a new free-form composition, or a new program for the composition it was made with. It is validated as attach_motion_composition validates one and becomes a NEW draft (the original piece and anything published from it stay as they are); the shots, voice-over and soundtrack the piece already made are reused while unchanged, not made or priced again. Spends nothing: read the new draft with resume_draft for its quote, and start it with start_job.

    Rate limit: 10 / minute

    Scope: jobs:write

    ›Request examples for revise_motion_piece
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/motion/freeform/revise' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"n":1}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.reviseMotionPiece({
      "jobId": "<jobId>",
      "n": 1
    })
  • Method: POST

    /api/v1/jobs/{jobId}/motion/regenerate

    Make one scene, one layer or one sound track of a draft plan’s motion graphics again (or mute a track), keeping everything else about the plan.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for regenerate_motion_part
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/motion/regenerate' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"n":1,"target":{"kind":"scene","sceneId":"<sceneId>"}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.regenerateMotionPart({
      "jobId": "<jobId>",
      "n": 1,
      "target": {
        "kind": "scene",
        "sceneId": "<sceneId>"
      }
    })
  • Method: POST

    /api/v1/jobs/{jobId}/motion/word-timing

    Choose how words follow the voice-over in a draft's motion graphics. `measured_lines` (the default): each line lands on its measured pause and its words are spread inside it. `aligned`: every word lands on the moment it is spoken, by transcribing the read with word timestamps; it is a priced step (a "word timing" line on the quote, from the transcription rate), and the quote refuses when it cannot be priced. Writes a new plan revision and spends nothing; read the draft back with resume_draft for the new quote.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for set_motion_word_timing
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/motion/word-timing' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"n":1,"mode":"measured_lines"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.setMotionWordTiming({
      "jobId": "<jobId>",
      "n": 1,
      "mode": "measured_lines"
    })
  • Method: POST

    /api/v1/jobs/{jobId}/narrator-voice

    Choose the narrator's voice for a draft before it starts, or clear the choice.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for set_draft_narrator_voice
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/narrator-voice' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"voiceKey":"<voiceKey>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.setDraftNarratorVoice({
      "jobId": "<jobId>",
      "voiceKey": "<voiceKey>"
    })
  • Method: POST

    /api/v1/jobs/{jobId}/plan-alternative

    Change a draft plan to one of the offered alternatives (a different model or resolution), keeping everything else about it. Returns the plan’s new price (estimateMicroUsd), which is not a quote. Spends nothing: read the draft back (resume_draft) for its new quote, and only that quote spends.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for apply_plan_alternative
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/plan-alternative' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"change":{"kind":"model","fromPresetId":"<fromPresetId>","toPresetId":"<toPresetId>"}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.applyPlanAlternative({
      "jobId": "<jobId>",
      "change": {
        "kind": "model",
        "fromPresetId": "<fromPresetId>",
        "toPresetId": "<toPresetId>"
      }
    })
  • Method: POST

    /api/v1/jobs/{jobId}/questions/{elicitationId}

    Answer a question a job is waiting on, and let it continue.

    Scope: jobs:write

    ›Request examples for answer_question
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/questions/<elicitationId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"answer":{"value":"<value>"}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.answerQuestion({
      "jobId": "<jobId>",
      "elicitationId": "<elicitationId>",
      "answer": {
        "value": "<value>"
      }
    })
  • Method: POST

    /api/v1/jobs/{jobId}/recast/questions/{elicitationId}

    Confirm the highlighted person or thing a Recast job will replace, or correct it: in words ("the man on the left"), or by marking a box or a point on the picture. The job then continues; the answer authorises nothing on its own and the price was already agreed.

    Scope: jobs:write

    ›Request examples for answer_recast_track
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/recast/questions/<elicitationId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"answer":{"kind":"confirm"}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.answerRecastTrack({
      "jobId": "<jobId>",
      "elicitationId": "<elicitationId>",
      "answer": {
        "kind": "confirm"
      }
    })
  • Method: POST

    /api/v1/jobs/{jobId}/resume

    Pick a saved draft back up from its saved plan: re-checked and re-priced as a fresh quote, ready to start. Read a draft back this way after changing it (edit_storyboard, apply_plan_alternative). Spends nothing.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for resume_draft
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/resume' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.resumeDraft({
      "jobId": "<jobId>"
    })
  • Method: POST

    /api/v1/jobs/{jobId}/retry

    Retry a failed job while its reserved credit is still held; otherwise get a prefilled new request.

    Rate limit: 20 / minute

    Scope: jobs:write

    ›Request examples for retry_failed_job
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/retry' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.retryFailedJob({
      "jobId": "<jobId>"
    })
  • Method: POST

    /api/v1/jobs/{jobId}/scene-layout

    Accept or decline the 3D layout proposed for a draft.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for accept_scene_layout
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/scene-layout' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"accept":false}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.acceptSceneLayout({
      "jobId": "<jobId>",
      "accept": false
    })
  • Method: POST

    /api/v1/jobs/{jobId}/shots/{shotIndex}/retry-request

    Ask to retry one shot of a job that is still running. The retry is priced and confirmed once the piece exists; nothing is spent now.

    Rate limit: 60 / minute

    Scope: jobs:write

    ›Request examples for request_shot_retry
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/shots/<shotIndex>/retry-request' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.requestShotRetry({
      "jobId": "<jobId>",
      "shotIndex": 1
    })
  • Method: POST

    /api/v1/jobs/{jobId}/shots/{shotIndex}/retry-request/cancel

    Withdraw a queued retry of a shot. Idempotent: one that is already gone is a success.

    Rate limit: 60 / minute

    Scope: jobs:write

    ›Request examples for cancel_shot_retry_request
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/shots/<shotIndex>/retry-request/cancel' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.cancelShotRetryRequest({
      "jobId": "<jobId>",
      "shotIndex": 1
    })
  • Method: POST

    /api/v1/jobs/{jobId}/start

    Start a planned draft from its quote.

    Rate limit: 20 / minute

    Scope: jobs:writeneeds a quote

    ›Request examples for start_job
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/start' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"quoteId":"<quoteId>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.startJob({
      "jobId": "<jobId>",
      "quoteId": "<quoteId>"
    })
  • Method: POST

    /api/v1/jobs/{jobId}/stills/{shotIndex}/pick

    Pick which picture a shot uses while the job is stopped on its stills review (get_job partialPause.frames): one of its candidate stills, or the result of a finished edit of one. Free: nothing is made or spent. Repeat to change the pick until the job goes on.

    Rate limit: 120 / minute

    Scope: jobs:write

    ›Request examples for pick_still
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/stills/<shotIndex>/pick' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"assetId":"<assetId>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.pickStill({
      "jobId": "<jobId>",
      "shotIndex": 1,
      "assetId": "<assetId>"
    })
  • Method: POST

    /api/v1/jobs/{jobId}/stills/controls

    Change a shot’s camera move or the picture its clip ends on while the job is stopped on its stills review (get_job partialPause.frames[].actions has camera or end_frame). Free: nothing is made or spent; the clip is made with the change.

    Rate limit: 60 / minute

    Scope: jobs:write

    ›Request examples for set_still_shot_control
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/stills/controls' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"edit":{"kind":"set_camera_control","shotIndex":1,"control":{"move":"static"}}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.setStillShotControl({
      "jobId": "<jobId>",
      "edit": {
        "kind": "set_camera_control",
        "shotIndex": 1,
        "control": {
          "move": "static"
        }
      }
    })
  • Method: POST

    /api/v1/jobs/{jobId}/storyboard/edits

    Change a draft plan on its storyboard (reorder, split, join, duplicate or remove a shot; its fields, length, camera, model, lines, sound effect, transition or lock; its typed camera control - move, direction, pace, motion (`set_camera_control`; the result says whether the model takes it as a control of its own or from the description, with the models that take it natively and their price); the picture it ends on - the next or an earlier shot’s opening picture, one of the person’s pictures, or a final frame in words made with the other frames (`set_end_frame`, only on a model that can end on a picture: otherwise refused with the models that can and their price); the shot’s prompt in the person’s own words, sent to the model exactly as written (`set_prompt_mode` `expert` with `prompt`; `composed` goes back to the prompt arranged from the shot’s fields; still moderated, only picture tags, the no-music clause and exclusions are added); storyboard frames; who speaks in which stock voice; a production step’s model, timing or which earlier step it is made from; restore a revision). Send one change as `edit` or up to 20 as `edits`, applied in order as ONE revision, all or nothing. Returns the price before and after; read the draft back with resume_draft for the quote to start with. A model swap the new model can make only with another length, frame or rung is refused (`capability_conflict`, reason `substitution_needed`, each change named and priced) until it is sent again with `acceptSubstitutions`.

    Rate limit: 60 / minute

    Scope: jobs:write

    ›Request examples for edit_storyboard
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/storyboard/edits' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"expectedRevision":1}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.editStoryboard({
      "jobId": "<jobId>",
      "expectedRevision": 1
    })
  • Method: POST

    /api/v1/jobs/{jobId}/storyboard/proposals

    Say in your own words what to change or include in a draft plan (the whole piece, or selected shots). Returns the changes it would make, each checked against the plan and priced, without changing anything; apply the ones you want with apply_storyboard_changes. Shots are numbered from 1 here, as a person says them ("shot 1" is the first; `dropped[].shot` too); `scope.shots` and every edit_storyboard field take the 0-based shotIndex ("shot 1" is shotIndex 0). An API key or assistant gets the built-in reader (`assistant: person_only`): it understands explicit edits (a shot’s framing, length, model, lines, order); a free-form look ("make the light warmer") is not understood there, so change the shot’s prompt with edit_storyboard instead.

    Rate limit: 10 / minute

    Scope: jobs:write

    ›Request examples for propose_storyboard_changes
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/storyboard/proposals' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"expectedRevision":1,"instruction":"<instruction>","scope":"piece"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.proposeStoryboardChanges({
      "jobId": "<jobId>",
      "expectedRevision": 1,
      "instruction": "<instruction>",
      "scope": "piece"
    })
  • Method: POST

    /api/v1/jobs/{jobId}/storyboard/proposals/{proposalId}/apply

    Apply the chosen changes from a storyboard proposal as one new plan revision. Read the draft back for its new price; restore the previous revision to undo.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for apply_storyboard_changes
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/storyboard/proposals/<proposalId>/apply' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"accept":["<accept>"]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.applyStoryboardChanges({
      "jobId": "<jobId>",
      "proposalId": "<proposalId>",
      "accept": [
        "<accept>"
      ]
    })
  • Method: POST

    /api/v1/jobs/{jobId}/systems

    Take systems Create added from the brief off a draft (motion, an animated ending, music, a dub, a Recast...), or put them back, and get the re-planned draft with a NEW quote and each system’s own price line. Never starts anything: start the new draft with start_job and its quoteId. A setting you stated is changed in the settings, not here.

    Rate limit: 10 / minute

    Scope: jobs:write

    ›Request examples for change_piece_systems
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/systems' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.changePieceSystems({
      "jobId": "<jobId>"
    })
  • Method: POST

    /api/v1/jobs/{jobId}/treatment/edits

    Change how a draft opens (its hook) or its beats (their times and roles) on a plan made with a treatment. The change is recorded as yours and never re-inferred; the draft is re-planned and returned with a NEW quote. Never starts anything: start the new draft with start_job and its quoteId. Only on a draft whose get_treatment says `editable`.

    Rate limit: 10 / minute

    Scope: jobs:write

    ›Request examples for edit_treatment
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/<jobId>/treatment/edits' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.editTreatment({
      "jobId": "<jobId>"
    })
  • Method: POST

    /api/v1/jobs/blocks/estimate

    Price an in-place change to one block of a piece.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for estimate_block_action
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/blocks/estimate' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"kind":"regenerate","contentPieceId":"<contentPieceId>","shotKey":1}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.estimateBlockAction({
      "kind": "regenerate",
      "contentPieceId": "<contentPieceId>",
      "shotKey": 1
    })
  • Method: POST

    /api/v1/jobs/blocks/regenerate

    Spend a block-action estimate and start the regeneration.

    Rate limit: 30 / minute

    Scope: jobs:writeidempotentneeds a quote

    ›Request examples for submit_block_regeneration
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/blocks/regenerate' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)" \
      -H 'Content-Type: application/json' \
      -d '{"quoteId":"<quoteId>","contentPieceId":"<contentPieceId>","shotKey":1}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.submitBlockRegeneration({
      "quoteId": "<quoteId>",
      "contentPieceId": "<contentPieceId>",
      "shotKey": 1,
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: POST

    /api/v1/jobs/estimate

    Price a job and return a single-use quote for it.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for estimate_job
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/estimate' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"service":"publishing","shots":[{"index":1,"prompt":"<prompt>"}]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.estimateJob({
      "service": "publishing",
      "shots": [
        {
          "index": 1,
          "prompt": "<prompt>"
        }
      ]
    })
  • Method: POST

    /api/v1/jobs/plan

    Start turning a brief into an editable shot list on a draft job; read the result with get_plan_run.

    Rate limit: 20 / minute

    Scope: jobs:writeidempotent

    ›Request examples for plan_job
    curl
    curl -X POST 'https://tonta.media/api/v1/jobs/plan' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)" \
      -H 'Content-Type: application/json' \
      -d '{"brief":"<brief>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.planJob({
      "brief": "<brief>",
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: POST

    /api/v1/offerings/import

    Read a product page and return a DRAFT offering (name, description, price, candidate pictures) for you to check and save with upsert_offering. Saves nothing; a picture becomes a reference only through the usual upload.

    Rate limit: 10 / minute

    Scope: jobs:write

    ›Request examples for import_offering_from_url
    curl
    curl -X POST 'https://tonta.media/api/v1/offerings/import' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"brandProfileId":"<brandProfileId>","url":"https://example.com/"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.importOfferingFromUrl({
      "brandProfileId": "<brandProfileId>",
      "url": "https://example.com/"
    })
  • Method: POST

    /api/v1/parts

    Quote one part (a clip, picture, voiceover, music, sound effect or 3D model) made by one model from your words. Spends nothing: start it with start_job.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for generate_part
    curl
    curl -X POST 'https://tonta.media/api/v1/parts' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"kind":"clip"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.generatePart({
      "kind": "clip"
    })
  • Method: POST

    /api/v1/parts/batch

    Quote a batch of parts as ONE job: N variations of one prompt, or one item per prompt. One quote that is the sum of its items, one hold; a failed item is refunded. Spends nothing: start it with start_job.

    Rate limit: 20 / minute

    Scope: jobs:writeidempotent

    ›Request examples for generate_parts_batch
    curl
    curl -X POST 'https://tonta.media/api/v1/parts/batch' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)" \
      -H 'Content-Type: application/json' \
      -d '{"kind":"clip"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.generatePartsBatch({
      "kind": "clip",
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: POST

    /api/v1/plan-runs/{planRunId}/cancel

    Stop a background plan. Only the planning work already done is charged.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for cancel_plan_run
    curl
    curl -X POST 'https://tonta.media/api/v1/plan-runs/<planRunId>/cancel' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.cancelPlanRun({
      "planRunId": "<planRunId>"
    })
  • Method: POST

    /api/v1/quotes/{quoteId}/decline

    Say no to a spend that is above your confirmation limit.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for decline_quote
    curl
    curl -X POST 'https://tonta.media/api/v1/quotes/<quoteId>/decline' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.declineQuote({
      "quoteId": "<quoteId>"
    })
  • Method: POST

    /api/v1/references/{referenceId}/voice-consents

    Ask for the words the speaker reads aloud to record their consent to a clone of their voice. A signed-in person only; an agent sends the person to the web.

    Rate limit: 10 / minute

    Scope: jobs:write

    ›Request examples for start_voice_consent_recording
    curl
    curl -X POST 'https://tonta.media/api/v1/references/<referenceId>/voice-consents' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.startVoiceConsentRecording({
      "referenceId": "<referenceId>"
    })
  • Method: POST

    /api/v1/references/from-asset

    Turn an output into a reusable reference.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for use_block_as_reference
    curl
    curl -X POST 'https://tonta.media/api/v1/references/from-asset' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"assetId":"<assetId>","kind":"character_sheet","name":"<name>","target":{"scope":"project","projectId":"<projectId>"}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.useBlockAsReference({
      "assetId": "<assetId>",
      "kind": "character_sheet",
      "name": "<name>",
      "target": {
        "scope": "project",
        "projectId": "<projectId>"
      }
    })
  • Method: POST

    /api/v1/scenes

    Start a new, persistent 3D scene.

    Rate limit: 20 / minute

    Scope: jobs:writeneeds a quote

    ›Request examples for create_scene_project
    curl
    curl -X POST 'https://tonta.media/api/v1/scenes' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"name":"<name>","quoteId":"<quoteId>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.createSceneProject({
      "name": "<name>",
      "quoteId": "<quoteId>"
    })
  • Method: GET

    /api/v1/scenes/{sceneProjectId}

    Read the current state of a scene: objects, cameras, lights, rigs.

    Rate limit: 60 / minute

    Scope: jobs:writeneeds a quote

    ›Request examples for get_scene
    curl
    curl -X GET 'https://tonta.media/api/v1/scenes/<sceneProjectId>?quoteId=%3CquoteId%3E' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getScene({
      "sceneProjectId": "<sceneProjectId>",
      "quoteId": "<quoteId>"
    })
  • Method: POST

    /api/v1/scenes/{sceneProjectId}/imports

    Import an existing 3D asset into a scene as a referenceable handle.

    Rate limit: 20 / minute

    Scope: jobs:writeneeds a quote

    ›Request examples for import_scene_asset
    curl
    curl -X POST 'https://tonta.media/api/v1/scenes/<sceneProjectId>/imports' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"assetId":"<assetId>","quoteId":"<quoteId>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.importSceneAsset({
      "sceneProjectId": "<sceneProjectId>",
      "assetId": "<assetId>",
      "quoteId": "<quoteId>"
    })
  • Method: POST

    /api/v1/scenes/{sceneProjectId}/ops

    Apply a batch of scene edits, never code, a closed, typed operation list.

    Rate limit: 30 / minute

    Scope: jobs:writeneeds a quote

    ›Request examples for apply_scene_ops
    curl
    curl -X POST 'https://tonta.media/api/v1/scenes/<sceneProjectId>/ops' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"ops":[{"op":"add_primitive","primitiveType":"cube","name":"<name>","location":{"x":1,"y":1,"z":1},"rotationDeg":{"x":1,"y":1,"z":1},"scale":{"x":1,"y":1,"z":1}}],"quoteId":"<quoteId>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.applySceneOps({
      "sceneProjectId": "<sceneProjectId>",
      "ops": [
        {
          "op": "add_primitive",
          "primitiveType": "cube",
          "name": "<name>",
          "location": {
            "x": 1,
            "y": 1,
            "z": 1
          },
          "rotationDeg": {
            "x": 1,
            "y": 1,
            "z": 1
          },
          "scale": {
            "x": 1,
            "y": 1,
            "z": 1
          }
        }
      ],
      "quoteId": "<quoteId>"
    })
  • Method: POST

    /api/v1/scenes/{sceneProjectId}/propose-ops

    Propose scene edits for an instruction, without applying them.

    Rate limit: 20 / minute

    Scope: jobs:write

    ›Request examples for propose_scene_ops
    curl
    curl -X POST 'https://tonta.media/api/v1/scenes/<sceneProjectId>/propose-ops' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"instruction":"<instruction>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.proposeSceneOps({
      "sceneProjectId": "<sceneProjectId>",
      "instruction": "<instruction>"
    })
  • Method: POST

    /api/v1/scenes/{sceneProjectId}/restore

    Restore an earlier version of a 3D scene as its newest version.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for restore_scene_revision
    curl
    curl -X POST 'https://tonta.media/api/v1/scenes/<sceneProjectId>/restore' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"expectedRevision":1,"toRevision":1}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.restoreSceneRevision({
      "sceneProjectId": "<sceneProjectId>",
      "expectedRevision": 1,
      "toRevision": 1
    })
  • Method: POST

    /api/v1/scenes/estimate

    Price one scene action before committing to it. The price is a ceiling (up to): it covers the longest the action may run, and the charge is what it actually uses, usually much less and never more.

    Rate limit: 120 / minute

    Scope: jobs:write

    ›Request examples for estimate_scene_action
    curl
    curl -X POST 'https://tonta.media/api/v1/scenes/estimate' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"tool":"create_project"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.estimateSceneAction({
      "tool": "create_project"
    })
  • Method: POST

    /api/v1/sessions

    Start a new conversation with the planning agent.

    Rate limit: 30 / minute

    Scope: jobs:write

    ›Request examples for start_session
    curl
    curl -X POST 'https://tonta.media/api/v1/sessions' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.startSession()
  • Method: POST

    /api/v1/sessions/{sessionId}/messages

    Add a message to a conversation.

    Rate limit: 60 / minute

    Scope: jobs:write

    ›Request examples for send_message
    curl
    curl -X POST 'https://tonta.media/api/v1/sessions/<sessionId>/messages' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"text":"<text>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.sendMessage({
      "sessionId": "<sessionId>",
      "text": "<text>"
    })
  • Method: POST

    /api/v1/sessions/{sessionId}/questions/{elicitationId}

    Answer a session-level question that is not waiting on any one job.

    Scope: jobs:write

    ›Request examples for answer_session_question
    curl
    curl -X POST 'https://tonta.media/api/v1/sessions/<sessionId>/questions/<elicitationId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"answer":{"value":"<value>"}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.answerSessionQuestion({
      "sessionId": "<sessionId>",
      "elicitationId": "<elicitationId>",
      "answer": {
        "value": "<value>"
      }
    })
  • Method: POST

    /api/v1/voice-consents/{recordingId}/recording

    Hand in the uploaded recording (60 seconds at most) of the speaker reading the words. Free; it is checked within minutes. A signed-in person only.

    Rate limit: 10 / minute

    Scope: jobs:write

    ›Request examples for submit_voice_consent_recording
    curl
    curl -X POST 'https://tonta.media/api/v1/voice-consents/<recordingId>/recording' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"assetId":"<assetId>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.submitVoiceConsentRecording({
      "recordingId": "<recordingId>",
      "assetId": "<assetId>"
    })
  • Method: POST

    /api/v1/voice-designs

    Price a voice designed from a description (who it sounds like in words: age, tone, pace, accent; never a real person). Returns a voiceDesignId with its quote; spends nothing. renewsReferenceId designs again a designed voice that was dropped after a week unused.

    Rate limit: 20 / minute

    Scope: jobs:write

    ›Request examples for estimate_voice_design
    curl
    curl -X POST 'https://tonta.media/api/v1/voice-designs' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.estimateVoiceDesign()
  • Method: POST

    /api/v1/voice-designs/{quoteId}/start

    Start a quoted voice design: redeems its quote and holds its credit. Above the confirmation threshold the person approves it on the web; your own statement that they agreed is never accepted.

    Rate limit: 20 / minute

    Scope: jobs:writeneeds a quote

    ›Request examples for start_voice_design
    curl
    curl -X POST 'https://tonta.media/api/v1/voice-designs/<quoteId>/start' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.startVoiceDesign({
      "quoteId": "<quoteId>"
    })
  • Method: GET

    /api/v1/knowledge

    What we know about the workspace as a whole (facts not tied to one brand), and what needs confirming.

    Rate limit: 60 / minute

    Scope: knowledge:read

    ›Request examples for list_workspace_facts
    curl
    curl -X GET 'https://tonta.media/api/v1/knowledge' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listWorkspaceFacts()
  • Method: POST

    /api/v1/brands/{brandProfileId}/facts

    Tell us something about this brand. From a signed-in person it is final and never re-guessed; from a key or an assistant it is kept as observed.

    Rate limit: 200 / hour

    Scope: knowledge:write

    ›Request examples for record_brand_fact
    curl
    curl -X POST 'https://tonta.media/api/v1/brands/<brandProfileId>/facts' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"key":"<key>","value":"<value>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.recordBrandFact({
      "brandProfileId": "<brandProfileId>",
      "key": "<key>",
      "value": "<value>"
    })
  • Method: POST

    /api/v1/knowledge/facts

    Tell us something about the whole workspace. From a signed-in person it is final and never re-guessed; from a key or an assistant it is kept as observed.

    Rate limit: 200 / hour

    Scope: knowledge:write

    ›Request examples for record_workspace_fact
    curl
    curl -X POST 'https://tonta.media/api/v1/knowledge/facts' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"key":"<key>","value":"<value>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.recordWorkspaceFact({
      "key": "<key>",
      "value": "<value>"
    })
  • Method: POST

    /api/v1/projects

    Create a project.

    Scope: projects:write

    ›Request examples for create_project
    curl
    curl -X POST 'https://tonta.media/api/v1/projects' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"service":"publishing","name":"<name>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.createProject({
      "service": "publishing",
      "name": "<name>"
    })
  • Method: PATCH

    /api/v1/projects/{projectId}

    Edit a project's name, description, brand, brand use or settings.

    Scope: projects:write

    ›Request examples for update_project
    curl
    curl -X PATCH 'https://tonta.media/api/v1/projects/<projectId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.updateProject({
      "projectId": "<projectId>"
    })
  • Method: POST

    /api/v1/projects/{projectId}/archive

    Archive a project: hidden from the default list, cannot start work; its running schedule is paused.

    Scope: projects:write

    ›Request examples for archive_project
    curl
    curl -X POST 'https://tonta.media/api/v1/projects/<projectId>/archive' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.archiveProject({
      "projectId": "<projectId>"
    })
  • Method: POST

    /api/v1/projects/{projectId}/bible

    Save a project's recurring cast, places and products. Everything saved here is what the customer stated.

    Rate limit: 30 / minute

    Scope: projects:write

    ›Request examples for save_project_bible
    curl
    curl -X POST 'https://tonta.media/api/v1/projects/<projectId>/bible' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"bible":{}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.saveProjectBible({
      "projectId": "<projectId>",
      "bible": {}
    })
  • Method: POST

    /api/v1/projects/{projectId}/bible/video-identity

    Make the person in a customer's video, her voice, look and place, a standing part of a project, so every run reuses them. Only where the customer already confirmed permission for that video in the library; this never records a permission.

    Rate limit: 30 / minute

    Scope: projects:write

    ›Request examples for adopt_project_video_identity
    curl
    curl -X POST 'https://tonta.media/api/v1/projects/<projectId>/bible/video-identity' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"videoReferenceId":"<videoReferenceId>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.adoptProjectVideoIdentity({
      "projectId": "<projectId>",
      "videoReferenceId": "<videoReferenceId>"
    })
  • Method: POST

    /api/v1/projects/{projectId}/cast

    Add or change one cast member, place or product of a project, with its standing choices, in one save. Everything saved here is what the customer stated.

    Rate limit: 60 / minute

    Scope: projects:write

    ›Request examples for save_cast_member
    curl
    curl -X POST 'https://tonta.media/api/v1/projects/<projectId>/cast' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.saveCastMember({
      "projectId": "<projectId>"
    })
  • Method: POST

    /api/v1/projects/{projectId}/readiness/answers

    Answer one of a project's missing details from its readiness checklist.

    Rate limit: 60 / minute

    Scope: projects:write

    ›Request examples for answer_project_question
    curl
    curl -X POST 'https://tonta.media/api/v1/projects/<projectId>/readiness/answers' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"key":"<key>","answer":{"value":"<value>"}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.answerProjectQuestion({
      "projectId": "<projectId>",
      "key": "<key>",
      "answer": {
        "value": "<value>"
      }
    })
  • Method: POST

    /api/v1/projects/{projectId}/settings/answer

    Answer a question about what a project is about, who it is for, its themes, tone or goal.

    Scope: projects:write

    ›Request examples for answer_project_setting
    curl
    curl -X POST 'https://tonta.media/api/v1/projects/<projectId>/settings/answer' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"path":"niche","answer":"<answer>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.answerProjectSetting({
      "projectId": "<projectId>",
      "path": "niche",
      "answer": "<answer>"
    })
  • Method: POST

    /api/v1/projects/{projectId}/story/canon/{factId}/retire

    Retire a fact from the story, as wrong (retracted) or replaced by a newer fact (superseded). It is kept in the history.

    Rate limit: 60 / minute

    Scope: projects:write

    ›Request examples for retire_canon_fact
    curl
    curl -X POST 'https://tonta.media/api/v1/projects/<projectId>/story/canon/<factId>/retire' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.retireCanonFact({
      "projectId": "<projectId>",
      "factId": "<factId>"
    })
  • Method: POST

    /api/v1/projects/{projectId}/story/variants

    Branch an alternate version of a scene or episode from the live record (or from another alternate). The live record is not touched.

    Rate limit: 30 / minute

    Scope: projects:write

    ›Request examples for create_story_variant
    curl
    curl -X POST 'https://tonta.media/api/v1/projects/<projectId>/story/variants' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"subjectType":"scene","subjectId":"<subjectId>","label":"<label>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.createStoryVariant({
      "projectId": "<projectId>",
      "subjectType": "scene",
      "subjectId": "<subjectId>",
      "label": "<label>"
    })
  • Method: POST

    /api/v1/projects/{projectId}/storyboard/place

    Move a shot under a scene of its episode, or back to not placed. This arranges the board; it does not change the finished piece.

    Rate limit: 120 / minute

    Scope: projects:write

    ›Request examples for place_storyboard_shot
    curl
    curl -X POST 'https://tonta.media/api/v1/projects/<projectId>/storyboard/place' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"episodeId":"<episodeId>","shotKey":"<shotKey>","sceneId":"<sceneId>","position":1}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.placeStoryboardShot({
      "projectId": "<projectId>",
      "episodeId": "<episodeId>",
      "shotKey": "<shotKey>",
      "sceneId": "<sceneId>",
      "position": 1
    })
  • Method: POST

    /api/v1/projects/{projectId}/unarchive

    Bring an archived project back. Its schedule stays paused until you resume it.

    Scope: projects:write

    ›Request examples for unarchive_project
    curl
    curl -X POST 'https://tonta.media/api/v1/projects/<projectId>/unarchive' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.unarchiveProject({
      "projectId": "<projectId>"
    })
  • Method: POST

    /api/v1/projects/{projectId}/world

    Save a project's world bible. Every entry changed here is what the customer stated, and is never re-inferred.

    Rate limit: 30 / minute

    Scope: projects:write

    ›Request examples for save_world_bible
    curl
    curl -X POST 'https://tonta.media/api/v1/projects/<projectId>/world' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"world":{}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.saveWorldBible({
      "projectId": "<projectId>",
      "world": {}
    })
  • Method: POST

    /api/v1/story/entities

    Add a cast member, place or product to a project, or to the library. Everything saved here is what the customer stated.

    Rate limit: 30 / minute

    Scope: projects:write

    ›Request examples for create_story_entity
    curl
    curl -X POST 'https://tonta.media/api/v1/story/entities' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"kind":"character","name":"<name>","attributes":{}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.createStoryEntity({
      "kind": "character",
      "name": "<name>",
      "attributes": {}
    })
  • Method: PATCH

    /api/v1/story/entities/{entityId}

    Change a cast member, place or product. The @-tag never changes.

    Rate limit: 60 / minute

    Scope: projects:write

    ›Request examples for update_story_entity
    curl
    curl -X PATCH 'https://tonta.media/api/v1/story/entities/<entityId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"expectedRevision":1}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.updateStoryEntity({
      "entityId": "<entityId>",
      "expectedRevision": 1
    })
  • Method: POST

    /api/v1/story/entities/{entityId}/archive

    Take a cast member, place or product out of use. It can be restored; its history stays.

    Rate limit: 60 / minute

    Scope: projects:write

    ›Request examples for archive_story_entity
    curl
    curl -X POST 'https://tonta.media/api/v1/story/entities/<entityId>/archive' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.archiveStoryEntity({
      "entityId": "<entityId>"
    })
  • Method: POST

    /api/v1/story/entities/{entityId}/restore

    Bring an archived cast member, place or product back. If its @-tag was taken meanwhile it returns under a new one.

    Rate limit: 60 / minute

    Scope: projects:write

    ›Request examples for restore_story_entity
    curl
    curl -X POST 'https://tonta.media/api/v1/story/entities/<entityId>/restore' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.restoreStoryEntity({
      "entityId": "<entityId>"
    })
  • Method: POST

    /api/v1/story/entities/{entityId}/states

    Record that a cast member, place or product changes from an episode on (a new outfit, an injury, a redecorated shop, a product that is opened). Everything saved here is what the customer stated.

    Rate limit: 30 / minute

    Scope: projects:write

    ›Request examples for add_entity_state
    curl
    curl -X POST 'https://tonta.media/api/v1/story/entities/<entityId>/states' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"change":{}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.addEntityState({
      "entityId": "<entityId>",
      "change": {}
    })
  • Method: POST

    /api/v1/story/entities/{entityId}/states/{stateId}/retire

    Take a change out of use. Later episodes stop applying it; it stays in the history.

    Rate limit: 60 / minute

    Scope: projects:write

    ›Request examples for retire_entity_state
    curl
    curl -X POST 'https://tonta.media/api/v1/story/entities/<entityId>/states/<stateId>/retire' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.retireEntityState({
      "entityId": "<entityId>",
      "stateId": "<stateId>"
    })
  • Method: POST

    /api/v1/calendar/{postId}/retry

    Put a failed post back for another attempt, or post one whose time passed ("Post now"). It goes out about a minute from now, through the same safe path every post takes. A post that may already be live is refused (409, `may_already_be_live`) until `acknowledgeMayAlreadyBeLive` says the person saw that warning (a person only: an assistant gets the post’s page instead).

    Rate limit: 30 / minute

    Scope: publish:write

    ›Request examples for retry_failed_post
    curl
    curl -X POST 'https://tonta.media/api/v1/calendar/<postId>/retry' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.retryFailedPost({
      "postId": "<postId>"
    })
  • Method: POST

    /api/v1/posts

    Schedule an approved piece to a connected account.

    Scope: publish:writeidempotent

    ›Request examples for schedule_post
    curl
    curl -X POST 'https://tonta.media/api/v1/posts' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)" \
      -H 'Content-Type: application/json' \
      -d '{"contentPieceId":"<contentPieceId>","connectionId":"<connectionId>","scheduledFor":"2026-10-09T09:00:00.000Z","timezone":"<timezone>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.schedulePost({
      "contentPieceId": "<contentPieceId>",
      "connectionId": "<connectionId>",
      "scheduledFor": "2026-10-09T09:00:00.000Z",
      "timezone": "<timezone>",
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: POST

    /api/v1/posts/multi/agent

    Schedule one approved piece to several accounts. A closure move or a repeat booking needs the customer to agree in the web calendar.

    Rate limit: 30 / minute

    Scope: publish:writeidempotent

    ›Request examples for schedule_post_multi_agent
    curl
    curl -X POST 'https://tonta.media/api/v1/posts/multi/agent' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)" \
      -H 'Content-Type: application/json' \
      -d '{"contentPieceId":"<contentPieceId>","scheduledFor":"2026-10-09T09:00:00.000Z","timezone":"<timezone>","targets":[{"connectionId":"<connectionId>"}]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.schedulePostMultiAgent({
      "contentPieceId": "<contentPieceId>",
      "scheduledFor": "2026-10-09T09:00:00.000Z",
      "timezone": "<timezone>",
      "idempotencyKey": crypto.randomUUID(),
      "targets": [
        {
          "connectionId": "<connectionId>"
        }
      ]
    })
  • Method: GET

    /api/v1/automation

    Every service this workspace has configured, and whether each is ready to run unattended.

    Scope: schedule:read

    ›Request examples for list_automations
    curl
    curl -X GET 'https://tonta.media/api/v1/automation' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listAutomations()
  • Method: GET

    /api/v1/automation/{serviceSubscriptionId}/clip-backlog

    The back-catalogue queue: what is waiting, how many clips remain and how long it lasts.

    Rate limit: 60 / minute

    Scope: schedule:read

    ›Request examples for list_clip_backlog
    curl
    curl -X GET 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/clip-backlog' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listClipBacklog({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: GET

    /api/v1/automation/{serviceSubscriptionId}/goal-suggestion

    The goal shown on a schedule's approval step: its agreed goal if it has one, else a suggestion to accept with the approval.

    Rate limit: 30 / minute

    Scope: schedule:read

    ›Request examples for get_schedule_goal_suggestion
    curl
    curl -X GET 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/goal-suggestion' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getScheduleGoalSuggestion({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: GET

    /api/v1/automation/{serviceSubscriptionId}/health

    How healthy one schedule is, and the one action that fixes each thing costing it points.

    Rate limit: 60 / minute

    Scope: schedule:read

    ›Request examples for get_schedule_health
    curl
    curl -X GET 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/health' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getScheduleHealth({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: GET

    /api/v1/automation/{serviceSubscriptionId}/plan

    What this automated service will do: aim, output, cost, schedule and references — built and persisted as the current draft.

    Scope: schedule:read

    ›Request examples for get_automation_plan
    curl
    curl -X GET 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/plan' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getAutomationPlan({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: GET

    /api/v1/automation/{serviceSubscriptionId}/plan-bias

    Why the plan leans the way it does: which pillars earn more turns, and any upcoming event it leans toward.

    Rate limit: 30 / minute

    Scope: schedule:read

    ›Request examples for get_schedule_plan_bias
    curl
    curl -X GET 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/plan-bias' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getSchedulePlanBias({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: GET

    /api/v1/automation/{serviceSubscriptionId}/readiness

    Whether a service may run unattended right now, and what is blocking it.

    Scope: schedule:read

    ›Request examples for get_automation_readiness
    curl
    curl -X GET 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/readiness' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getAutomationReadiness({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: GET

    /api/v1/automation/{serviceSubscriptionId}/recycle-suggestions

    Your best pieces, offered for a re-run with a fresh hook or a per-platform version. Nothing is made or charged unless you choose it.

    Rate limit: 30 / minute

    Scope: schedule:read

    ›Request examples for list_recycle_suggestions
    curl
    curl -X GET 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/recycle-suggestions' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listRecycleSuggestions({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: GET

    /api/v1/automation/{serviceSubscriptionId}/reshare

    Your best published pieces that could be shared again, and whether re-sharing is on.

    Rate limit: 60 / minute

    Scope: schedule:read

    ›Request examples for list_reshare_proposals
    curl
    curl -X GET 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/reshare' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listReshareProposals({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: GET

    /api/v1/automation/{serviceSubscriptionId}/runway

    How many more runs your credit and monthly cap cover, and when the next run is.

    Rate limit: 30 / minute

    Scope: schedule:read

    ›Request examples for get_schedule_runway
    curl
    curl -X GET 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/runway' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getScheduleRunway({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: GET

    /api/v1/automation/{serviceSubscriptionId}/settings

    A configured cadence's full settings, plus what each unset field resolves to.

    Scope: schedule:read

    ›Request examples for get_service_subscription_settings
    curl
    curl -X GET 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/settings' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getServiceSubscriptionSettings({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: GET

    /api/v1/automation/{serviceSubscriptionId}/settings/agent

    A configured cadence's full settings, plus what each unset field resolves to — read-only.

    Rate limit: 60 / minute

    Scope: schedule:read

    ›Request examples for get_service_settings
    curl
    curl -X GET 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/settings/agent' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getServiceSettings({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: GET

    /api/v1/automation/{serviceSubscriptionId}/slot-suggestions

    Better posting days and times for this schedule, from how your own posts performed. Suggestions only.

    Rate limit: 30 / minute

    Scope: schedule:read

    ›Request examples for list_posting_slot_suggestions
    curl
    curl -X GET 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/slot-suggestions' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listPostingSlotSuggestions({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: GET

    /api/v1/automation/{serviceSubscriptionId}/topics

    A schedule’s topic ledger: what is queued next, what was made, left out or suggested, where each came from, and whether it is running low.

    Rate limit: 60 / minute

    Scope: schedule:read

    ›Request examples for list_schedule_topics
    curl
    curl -X GET 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/topics' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listScheduleTopics({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: POST

    /api/v1/automation/budget-estimate

    Check a schedule's budget against what its cadence costs.

    Rate limit: 60 / minute

    Scope: schedule:read

    ›Request examples for estimate_schedule_budget
    curl
    curl -X POST 'https://tonta.media/api/v1/automation/budget-estimate' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"service":"publishing"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.estimateScheduleBudget({
      "service": "publishing"
    })
  • Method: GET

    /api/v1/automation/mix-adjustments

    What the weekly review changed in a schedule’s topic and format mix (or suggested for its posting times), newest first, each with why. Omit the schedule for the whole workspace.

    Rate limit: 60 / minute

    Scope: schedule:read

    ›Request examples for list_schedule_mix_adjustments
    curl
    curl -X GET 'https://tonta.media/api/v1/automation/mix-adjustments' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listScheduleMixAdjustments()
  • Method: GET

    /api/v1/brands/{brandProfileId}/connect-unlock

    Whether this brand can connect new accounts, and what is left to unlock it.

    Rate limit: 60 / minute

    Scope: schedule:read

    ›Request examples for get_connect_unlock_status
    curl
    curl -X GET 'https://tonta.media/api/v1/brands/<brandProfileId>/connect-unlock' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getConnectUnlockStatus({
      "brandProfileId": "<brandProfileId>"
    })
  • Method: GET

    /api/v1/calendar

    Scheduled posts between two dates.

    Scope: schedule:read

    ›Request examples for list_calendar
    curl
    curl -X GET 'https://tonta.media/api/v1/calendar?from=2026-10-09T09%3A00%3A00.000Z&to=2026-10-09T09%3A00%3A00.000Z' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listCalendar({
      "from": "2026-10-09T09:00:00.000Z",
      "to": "2026-10-09T09:00:00.000Z"
    })
  • Method: GET

    /api/v1/calendar/{postId}

    One scheduled post, the same piece on other platforms, and what has happened to it.

    Rate limit: 120 / minute

    Scope: schedule:read

    ›Request examples for get_scheduled_post
    curl
    curl -X GET 'https://tonta.media/api/v1/calendar/<postId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getScheduledPost({
      "postId": "<postId>"
    })
  • Method: POST

    /api/v1/calendar/{postId}/check

    What would happen if this post moved to that time - nothing is moved.

    Rate limit: 240 / minute

    Scope: schedule:read

    ›Request examples for check_post_move
    curl
    curl -X POST 'https://tonta.media/api/v1/calendar/<postId>/check' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"scheduledFor":"2026-10-09T09:00:00.000Z"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.checkPostMove({
      "postId": "<postId>",
      "scheduledFor": "2026-10-09T09:00:00.000Z"
    })
  • Method: POST

    /api/v1/calendar/check

    What each chosen account would do with this piece at this time - nothing is booked.

    Rate limit: 120 / minute

    Scope: schedule:read

    ›Request examples for check_schedule
    curl
    curl -X POST 'https://tonta.media/api/v1/calendar/check' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"contentPieceId":"<contentPieceId>","targets":[{"connectionId":"<connectionId>"}]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.checkSchedule({
      "contentPieceId": "<contentPieceId>",
      "targets": [
        {
          "connectionId": "<connectionId>"
        }
      ]
    })
  • Method: GET

    /api/v1/calendar/drafts

    Your unsent drafts, newest first (at most 100).

    Scope: schedule:read

    ›Request examples for list_post_drafts
    curl
    curl -X GET 'https://tonta.media/api/v1/calendar/drafts' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listPostDrafts()
  • Method: GET

    /api/v1/calendar/layers

    One window of the calendar: posts, projected schedule slots, closures, events - filtered, bucketed by your time zone.

    Rate limit: 120 / minute

    Scope: schedule:read

    ›Request examples for get_calendar_layers
    curl
    curl -X GET 'https://tonta.media/api/v1/calendar/layers?from=2026-10-09T09%3A00%3A00.000Z&to=2026-10-09T09%3A00%3A00.000Z' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getCalendarLayers({
      "from": "2026-10-09T09:00:00.000Z",
      "to": "2026-10-09T09:00:00.000Z"
    })
  • Method: GET

    /api/v1/connections

    Your connected accounts and their health.

    Scope: schedule:read

    ›Request examples for list_connections
    curl
    curl -X GET 'https://tonta.media/api/v1/connections' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listConnections()
  • Method: GET

    /api/v1/connections/{connectionId}/health

    How one connected account is doing: the last check, what it found, the last publish, when it is next checked and what is waiting on it.

    Rate limit: 60 / minute

    Scope: schedule:read

    ›Request examples for get_connection_health
    curl
    curl -X GET 'https://tonta.media/api/v1/connections/<connectionId>/health' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getConnectionHealth({
      "connectionId": "<connectionId>"
    })
  • Method: GET

    /api/v1/connections/{connectionId}/targets

    The Pages, boards or locations this connection can publish to.

    Rate limit: 20 / minute

    Scope: schedule:read

    ›Request examples for list_publish_targets
    curl
    curl -X GET 'https://tonta.media/api/v1/connections/<connectionId>/targets' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listPublishTargets({
      "connectionId": "<connectionId>"
    })
  • Method: GET

    /api/v1/connections/{connectionId}/trending-sounds

    The platform’s own trending sounds for one connected account, to add to a video post by the platform’s sound id. Says so when the platform cannot take a sound from us. Never posts.

    Rate limit: 20 / minute

    Scope: schedule:read

    ›Request examples for list_trending_sounds
    curl
    curl -X GET 'https://tonta.media/api/v1/connections/<connectionId>/trending-sounds' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listTrendingSounds({
      "connectionId": "<connectionId>"
    })
  • Method: GET

    /api/v1/connections/prerequisites

    What each platform needs before you connect it.

    Scope: schedule:read

    ›Request examples for list_platform_prerequisites
    curl
    curl -X GET 'https://tonta.media/api/v1/connections/prerequisites' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listPlatformPrerequisites()
  • Method: GET

    /api/v1/content-languages

    Every language a service can write, narrate and caption in.

    Rate limit: 60 / minute

    Scope: schedule:read

    ›Request examples for list_content_languages
    curl
    curl -X GET 'https://tonta.media/api/v1/content-languages' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listContentLanguages()
  • Method: GET

    /api/v1/jobs/{jobId}/publishing

    Where each of a job's pieces is scheduled or published, and the fields each post carries.

    Rate limit: 120 / minute

    Scope: schedule:read

    ›Request examples for get_job_publishing
    curl
    curl -X GET 'https://tonta.media/api/v1/jobs/<jobId>/publishing' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getJobPublishing({
      "jobId": "<jobId>"
    })
  • Method: GET

    /api/v1/motion/blocks

    The motion-graphics blocks, transitions and components a piece can use.

    Rate limit: 60 / minute

    Scope: schedule:read

    ›Request examples for list_motion_blocks
    curl
    curl -X GET 'https://tonta.media/api/v1/motion/blocks' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listMotionBlocks()
  • Method: GET

    /api/v1/pieces/{contentPieceId}/publish-check

    A pre-publish check of a finished piece for each platform: shape, length, the first two seconds, sound, captions against the platform’s buttons, readability. Explained, free, never blocks posting, and never a prediction of views.

    Rate limit: 30 / minute

    Scope: schedule:read

    ›Request examples for score_piece_for_publish
    curl
    curl -X GET 'https://tonta.media/api/v1/pieces/<contentPieceId>/publish-check?platforms=%3Cplatforms%3E' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.scorePieceForPublish({
      "contentPieceId": "<contentPieceId>",
      "platforms": "<platforms>"
    })
  • Method: GET

    /api/v1/platform-capabilities

    What each platform you can connect supports: media, caption length, links, scheduling. Only platforms available right now.

    Rate limit: 60 / minute

    Scope: schedule:read

    ›Request examples for list_platform_capabilities
    curl
    curl -X GET 'https://tonta.media/api/v1/platform-capabilities' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listPlatformCapabilities()
  • Method: GET

    /api/v1/platforms

    Every platform a cadence may target, with how well Tonta supports each.

    Rate limit: 60 / minute

    Scope: schedule:read

    ›Request examples for list_supported_platforms
    curl
    curl -X GET 'https://tonta.media/api/v1/platforms' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listSupportedPlatforms()
  • Method: GET

    /api/v1/projects/{projectId}/schedule-defaults

    What a new schedule for this project starts from: connected platforms, a weekly slot grid, approval, budget and disclosure, each with where it came from.

    Rate limit: 30 / minute

    Scope: schedule:read

    ›Request examples for get_schedule_setup_defaults
    curl
    curl -X GET 'https://tonta.media/api/v1/projects/<projectId>/schedule-defaults' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getScheduleSetupDefaults({
      "projectId": "<projectId>"
    })
  • Method: GET

    /api/v1/publish-context

    Whether a piece can be published now, which brand it is for, and what is already booked for it. Reads only; publishing re-checks everything.

    Rate limit: 120 / minute

    Scope: schedule:read

    ›Request examples for get_publish_context
    curl
    curl -X GET 'https://tonta.media/api/v1/publish-context' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getPublishContext()
  • Method: GET

    /api/v1/services/{service}/settings-schema

    A service's settings schema, defaults and per-field help — before any project or schedule exists.

    Rate limit: 60 / minute

    Scope: schedule:read

    ›Request examples for get_service_settings_schema
    curl
    curl -X GET 'https://tonta.media/api/v1/services/<service>/settings-schema' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getServiceSettingsSchema({
      "service": "publishing"
    })
  • Method: GET

    /api/v1/voices

    The stock narration voices a service can speak in. Filter by `language` (a BCP 47 primary subtag, "en") and `gender`, and page with `limit` and the `nextCursor` it returns: the whole catalogue is large, so an assistant should ask for a page.

    Rate limit: 60 / minute

    Scope: schedule:read

    ›Request examples for list_voices
    curl
    curl -X GET 'https://tonta.media/api/v1/voices' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listVoices()
  • Method: GET

    /api/v1/voices/{voiceKey}/sample

    Play a stock voice before choosing it: its short sample as inline audio (base64), or why there is none yet. Spends nothing.

    Rate limit: 30 / minute

    Scope: schedule:read

    ›Request examples for get_voice_sample
    curl
    curl -X GET 'https://tonta.media/api/v1/voices/<voiceKey>/sample' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getVoiceSample({
      "voiceKey": "<voiceKey>"
    })
  • Method: POST

    /api/v1/automation

    Set up a recurring content schedule (a cadence, for example three posts a week) for a service — onboarding, not yet approved to run unattended.

    Rate limit: 10 / minute

    Scope: schedule:writeidempotent

    ›Request examples for create_service_subscription
    curl
    curl -X POST 'https://tonta.media/api/v1/automation' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)" \
      -H 'Content-Type: application/json' \
      -d '{"service":"publishing"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.createServiceSubscription({
      "service": "publishing",
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: POST

    /api/v1/automation/{serviceSubscriptionId}/clip-backlog

    Queue existing videos, or older episodes of this schedule’s own feed. Adding never starts the drip.

    Rate limit: 20 / minute

    Scope: schedule:write

    ›Request examples for add_clip_backlog
    curl
    curl -X POST 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/clip-backlog' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.addClipBacklog({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: DELETE

    /api/v1/automation/{serviceSubscriptionId}/clip-backlog/{itemId}

    Take a video out of the queue before it is taken.

    Rate limit: 60 / minute

    Scope: schedule:write

    ›Request examples for remove_clip_backlog_item
    curl
    curl -X DELETE 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/clip-backlog/<itemId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.removeClipBacklogItem({
      "serviceSubscriptionId": "<serviceSubscriptionId>",
      "itemId": "<itemId>"
    })
  • Method: POST

    /api/v1/automation/{serviceSubscriptionId}/clip-backlog/drip

    Turn the back-catalogue queue on or off. On starts taking videos at the schedule’s rhythm and spends credit per video, so only the person turns it on; an assistant may turn it off.

    Rate limit: 20 / minute

    Scope: schedule:write

    ›Request examples for set_clip_drip
    curl
    curl -X POST 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/clip-backlog/drip' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"enabled":false}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.setClipDrip({
      "serviceSubscriptionId": "<serviceSubscriptionId>",
      "enabled": false
    })
  • Method: POST

    /api/v1/automation/{serviceSubscriptionId}/pause

    Stop a running cadence. Scheduled runs stop; nothing already queued is cancelled.

    Rate limit: 20 / minute

    Scope: schedule:write

    ›Request examples for pause_automation
    curl
    curl -X POST 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/pause' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.pauseAutomation({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: POST

    /api/v1/automation/{serviceSubscriptionId}/reshare/{proposalId}/dismiss

    Say no to a re-share suggestion. It is remembered and not suggested again for the same piece and platform.

    Rate limit: 60 / minute

    Scope: schedule:write

    ›Request examples for dismiss_reshare
    curl
    curl -X POST 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/reshare/<proposalId>/dismiss' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.dismissReshare({
      "serviceSubscriptionId": "<serviceSubscriptionId>",
      "proposalId": "<proposalId>"
    })
  • Method: POST

    /api/v1/automation/{serviceSubscriptionId}/resume

    Start a paused cadence back up, from its next scheduled slot.

    Rate limit: 20 / minute

    Scope: schedule:write

    ›Request examples for resume_automation
    curl
    curl -X POST 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/resume' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.resumeAutomation({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: PATCH

    /api/v1/automation/{serviceSubscriptionId}/settings

    Edit a configured cadence's settings.

    Rate limit: 30 / minute

    Scope: schedule:write

    ›Request examples for update_service_subscription_settings
    curl
    curl -X PATCH 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/settings' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"expectedUpdatedAt":"2026-10-09T09:00:00.000Z"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.updateServiceSubscriptionSettings({
      "serviceSubscriptionId": "<serviceSubscriptionId>",
      "expectedUpdatedAt": "2026-10-09T09:00:00.000Z"
    })
  • Method: POST

    /api/v1/automation/{serviceSubscriptionId}/topic-strategy

    Choose where this schedule’s topics come from: kept filled for you, only your own list, or fresh takes on your best pieces first. Changes no spend.

    Rate limit: 30 / minute

    Scope: schedule:write

    ›Request examples for set_schedule_topic_strategy
    curl
    curl -X POST 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/topic-strategy' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"strategy":"auto"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.setScheduleTopicStrategy({
      "serviceSubscriptionId": "<serviceSubscriptionId>",
      "strategy": "auto"
    })
  • Method: POST

    /api/v1/automation/{serviceSubscriptionId}/topics

    Add your own topics to the end of the queue. An exact repeat is ignored; a near-repeat is returned in `repeats` and not added unless `allowRepeat`.

    Rate limit: 30 / minute

    Scope: schedule:write

    ›Request examples for add_schedule_topics
    curl
    curl -X POST 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/topics' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"topics":[{"title":"<title>"}]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.addScheduleTopics({
      "serviceSubscriptionId": "<serviceSubscriptionId>",
      "topics": [
        {
          "title": "<title>"
        }
      ]
    })
  • Method: DELETE

    /api/v1/automation/{serviceSubscriptionId}/topics/{topicId}

    Remove a topic that has not been made yet. One the idea engine proposed is kept as left out, so it is never proposed again.

    Rate limit: 60 / minute

    Scope: schedule:write

    ›Request examples for remove_schedule_topic
    curl
    curl -X DELETE 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/topics/<topicId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.removeScheduleTopic({
      "serviceSubscriptionId": "<serviceSubscriptionId>",
      "topicId": "<topicId>"
    })
  • Method: PATCH

    /api/v1/automation/{serviceSubscriptionId}/topics/{topicId}

    Change a topic that has not been made yet. Yours from then on: the idea engine never changes it. A title that repeats another is a 409 naming it, unless `allowRepeat`.

    Rate limit: 60 / minute

    Scope: schedule:write

    ›Request examples for edit_schedule_topic
    curl
    curl -X PATCH 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/topics/<topicId>' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.editScheduleTopic({
      "serviceSubscriptionId": "<serviceSubscriptionId>",
      "topicId": "<topicId>"
    })
  • Method: POST

    /api/v1/automation/{serviceSubscriptionId}/topics/{topicId}/decision

    Accept a suggested topic into the queue, or dismiss it.

    Rate limit: 60 / minute

    Scope: schedule:write

    ›Request examples for decide_topic_suggestion
    curl
    curl -X POST 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/topics/<topicId>/decision' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"decision":"accept"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.decideTopicSuggestion({
      "serviceSubscriptionId": "<serviceSubscriptionId>",
      "topicId": "<topicId>",
      "decision": "accept"
    })
  • Method: POST

    /api/v1/automation/{serviceSubscriptionId}/topics/order

    Set the order of the queued topics. Send exactly the queued ids; a stale list is a 409.

    Rate limit: 30 / minute

    Scope: schedule:write

    ›Request examples for reorder_schedule_topics
    curl
    curl -X POST 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/topics/order' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"orderedIds":["<orderedIds>"]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.reorderScheduleTopics({
      "serviceSubscriptionId": "<serviceSubscriptionId>",
      "orderedIds": [
        "<orderedIds>"
      ]
    })
  • Method: POST

    /api/v1/automation/{serviceSubscriptionId}/topics/suggest

    Propose next topics. They wait as suggestions until you accept them; nothing is added or made.

    Rate limit: 10 / minute

    Scope: schedule:write

    ›Request examples for suggest_schedule_topics
    curl
    curl -X POST 'https://tonta.media/api/v1/automation/<serviceSubscriptionId>/topics/suggest' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.suggestScheduleTopics({
      "serviceSubscriptionId": "<serviceSubscriptionId>"
    })
  • Method: POST

    /api/v1/calendar/{postId}/cancel

    Cancel a scheduled post before it goes out.

    Rate limit: 60 / minute

    Scope: schedule:write

    ›Request examples for cancel_scheduled_post
    curl
    curl -X POST 'https://tonta.media/api/v1/calendar/<postId>/cancel' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.cancelScheduledPost({
      "postId": "<postId>"
    })
  • Method: POST

    /api/v1/calendar/{postId}/reschedule

    Move a scheduled post to a different time.

    Rate limit: 60 / minute

    Scope: schedule:write

    ›Request examples for reschedule_post
    curl
    curl -X POST 'https://tonta.media/api/v1/calendar/<postId>/reschedule' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Content-Type: application/json' \
      -d '{"scheduledFor":"2026-10-09T09:00:00.000Z"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.reschedulePost({
      "postId": "<postId>",
      "scheduledFor": "2026-10-09T09:00:00.000Z"
    })
  • Method: POST

    /api/v1/calendar/bulk/cancel

    Cancel many scheduled posts at once - all or nothing, with a reason for each post that cannot be canceled.

    Rate limit: 20 / minute

    Scope: schedule:writeidempotent

    ›Request examples for bulk_cancel_posts
    curl
    curl -X POST 'https://tonta.media/api/v1/calendar/bulk/cancel' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)" \
      -H 'Content-Type: application/json' \
      -d '{"postIds":["<postIds>"]}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.bulkCancelPosts({
      "postIds": [
        "<postIds>"
      ],
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: POST

    /api/v1/calendar/bulk/reschedule

    Move many scheduled posts at once - all or nothing, with a reason for each post that cannot move.

    Rate limit: 20 / minute

    Scope: schedule:writeidempotent

    ›Request examples for bulk_reschedule_posts
    curl
    curl -X POST 'https://tonta.media/api/v1/calendar/bulk/reschedule' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)" \
      -H 'Content-Type: application/json' \
      -d '{"postIds":["<postIds>"],"move":{"kind":"shift","days":1,"hours":1,"minutes":1}}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.bulkReschedulePosts({
      "postIds": [
        "<postIds>"
      ],
      "move": {
        "kind": "shift",
        "days": 1,
        "hours": 1,
        "minutes": 1
      },
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: POST

    /api/v1/calendar/drafts

    Save an unsent post for one account. A draft is never published; scheduling it for real is a separate step.

    Rate limit: 60 / minute

    Scope: schedule:writeidempotent

    ›Request examples for save_post_draft
    curl
    curl -X POST 'https://tonta.media/api/v1/calendar/drafts' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY" \
      -H 'Idempotency-Key: '"$(uuidgen)" \
      -H 'Content-Type: application/json' \
      -d '{"contentPieceId":"<contentPieceId>","connectionId":"<connectionId>","timezone":"<timezone>"}'
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.savePostDraft({
      "contentPieceId": "<contentPieceId>",
      "connectionId": "<connectionId>",
      "timezone": "<timezone>",
      "idempotencyKey": crypto.randomUUID()
    })
  • Method: POST

    /api/v1/calendar/drafts/{draftId}/discard

    Delete an unsent draft. Idempotent: one that is already gone is a success.

    Rate limit: 60 / minute

    Scope: schedule:write

    ›Request examples for discard_post_draft
    curl
    curl -X POST 'https://tonta.media/api/v1/calendar/drafts/<draftId>/discard' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.discardPostDraft({
      "draftId": "<draftId>"
    })
  • Method: GET

    /api/v1/billing/add-ons

    Add-ons you can buy on your current plan, and the ones you already hold.

    Scope: usage:read

    ›Request examples for list_workspace_add_ons
    curl
    curl -X GET 'https://tonta.media/api/v1/billing/add-ons' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listWorkspaceAddOns()
  • Method: GET

    /api/v1/billing/auto-refill

    Today's automatic top-up setting, without changing it.

    Scope: usage:read

    ›Request examples for get_auto_refill
    curl
    curl -X GET 'https://tonta.media/api/v1/billing/auto-refill' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getAutoRefill()
  • Method: GET

    /api/v1/billing/balance

    Credit available now, and what is reserved against running work.

    Scope: usage:read

    ›Request examples for get_balance
    curl
    curl -X GET 'https://tonta.media/api/v1/billing/balance' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getBalance()
  • Method: GET

    /api/v1/billing/credit-add-ons

    Extra brands and seats you can buy from credit, and the ones you hold.

    Scope: usage:read

    ›Request examples for list_credit_add_ons
    curl
    curl -X GET 'https://tonta.media/api/v1/billing/credit-add-ons' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listCreditAddOns()
  • Method: GET

    /api/v1/billing/credit/packs

    The credit packs available to buy.

    Scope: usage:read

    ›Request examples for list_credit_packs
    curl
    curl -X GET 'https://tonta.media/api/v1/billing/credit/packs' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listCreditPacks()
  • Method: GET

    /api/v1/billing/spend

    What your credits were spent on, itemised. With no window given, the last 30 days up to now; the answer says the window it used.

    Scope: usage:read

    ›Request examples for get_spend_summary
    curl
    curl -X GET 'https://tonta.media/api/v1/billing/spend' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getSpendSummary()
  • Method: GET

    /api/v1/billing/storage-overage

    The included storage allowance, the storage and delivery rates above it, and whether this workspace has opted in.

    Scope: usage:read

    ›Request examples for get_storage_overage
    curl
    curl -X GET 'https://tonta.media/api/v1/billing/storage-overage' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getStorageOverage()
  • Method: GET

    /api/v1/billing/subscription

    Your plan, when it renews and what it will cost.

    Scope: usage:read

    ›Request examples for get_subscription
    curl
    curl -X GET 'https://tonta.media/api/v1/billing/subscription' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getSubscription()
  • Method: GET

    /api/v1/content/stats

    Pieces produced and published, itemised by service.

    Scope: usage:read

    ›Request examples for get_content_stats
    curl
    curl -X GET 'https://tonta.media/api/v1/content/stats?from=2026-10-09T09%3A00%3A00.000Z&to=2026-10-09T09%3A00%3A00.000Z' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getContentStats({
      "from": "2026-10-09T09:00:00.000Z",
      "to": "2026-10-09T09:00:00.000Z"
    })
  • Method: GET

    /api/v1/content/top-pieces

    Pieces ranked by a measured performance metric.

    Scope: usage:read

    ›Request examples for list_top_pieces
    curl
    curl -X GET 'https://tonta.media/api/v1/content/top-pieces?from=2026-10-09T09%3A00%3A00.000Z&to=2026-10-09T09%3A00%3A00.000Z&metric=%3Cmetric%3E' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listTopPieces({
      "from": "2026-10-09T09:00:00.000Z",
      "to": "2026-10-09T09:00:00.000Z",
      "metric": "<metric>"
    })
  • Method: GET

    /api/v1/entitlements

    What your plan and add-ons allow.

    Scope: usage:read

    ›Request examples for get_entitlements
    curl
    curl -X GET 'https://tonta.media/api/v1/entitlements' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getEntitlements()
  • Method: GET

    /api/v1/insights/accounts

    Daily account-level readings (followers, reach, impressions) per connected account.

    Scope: usage:read

    ›Request examples for list_account_metrics
    curl
    curl -X GET 'https://tonta.media/api/v1/insights/accounts?from=2026-10-09T09%3A00%3A00.000Z&to=2026-10-09T09%3A00%3A00.000Z' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listAccountMetrics({
      "from": "2026-10-09T09:00:00.000Z",
      "to": "2026-10-09T09:00:00.000Z"
    })
  • Method: GET

    /api/v1/insights/audience

    Audience demographics, follower activity by hour and follower flow, per connected account that offers them.

    Scope: usage:read

    ›Request examples for get_insights_audience
    curl
    curl -X GET 'https://tonta.media/api/v1/insights/audience?from=2026-10-09T09%3A00%3A00.000Z&to=2026-10-09T09%3A00%3A00.000Z' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getInsightsAudience({
      "from": "2026-10-09T09:00:00.000Z",
      "to": "2026-10-09T09:00:00.000Z"
    })
  • Method: GET

    /api/v1/insights/dashboard

    Everything Insights knows about the connected accounts for a range: account readings per platform, the account's posts (including ones made outside Tonta), engagement rate, per-platform split, posting-time heatmap, and the same figures for the period before.

    Scope: usage:read

    ›Request examples for get_insights_dashboard
    curl
    curl -X GET 'https://tonta.media/api/v1/insights/dashboard?from=2026-10-09T09%3A00%3A00.000Z&to=2026-10-09T09%3A00%3A00.000Z' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getInsightsDashboard({
      "from": "2026-10-09T09:00:00.000Z",
      "to": "2026-10-09T09:00:00.000Z"
    })
  • Method: GET

    /api/v1/insights/export

    A CSV of every published post's latest metrics in a range.

    Rate limit: 6 / minute

    Scope: usage:read

    ›Request examples for export_insights_csv
    curl
    curl -X GET 'https://tonta.media/api/v1/insights/export?from=2026-10-09T09%3A00%3A00.000Z&to=2026-10-09T09%3A00%3A00.000Z' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.exportInsightsCsv({
      "from": "2026-10-09T09:00:00.000Z",
      "to": "2026-10-09T09:00:00.000Z"
    })
  • Method: GET

    /api/v1/insights/overview

    Headline metrics for a range against the equal-length period before it.

    Scope: usage:read

    ›Request examples for get_insights_overview
    curl
    curl -X GET 'https://tonta.media/api/v1/insights/overview?from=2026-10-09T09%3A00%3A00.000Z&to=2026-10-09T09%3A00%3A00.000Z' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getInsightsOverview({
      "from": "2026-10-09T09:00:00.000Z",
      "to": "2026-10-09T09:00:00.000Z"
    })
  • Method: GET

    /api/v1/insights/posts

    The account's posts in a range (made in Tonta or imported from the platform), ranked by a metric.

    Scope: usage:read

    ›Request examples for list_insights_posts
    curl
    curl -X GET 'https://tonta.media/api/v1/insights/posts?from=2026-10-09T09%3A00%3A00.000Z&to=2026-10-09T09%3A00%3A00.000Z' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listInsightsPosts({
      "from": "2026-10-09T09:00:00.000Z",
      "to": "2026-10-09T09:00:00.000Z"
    })
  • Method: GET

    /api/v1/insights/timeseries

    A performance metric over time, across the posts published in a range.

    Scope: usage:read

    ›Request examples for list_insights_timeseries
    curl
    curl -X GET 'https://tonta.media/api/v1/insights/timeseries?from=2026-10-09T09%3A00%3A00.000Z&to=2026-10-09T09%3A00%3A00.000Z&metric=%3Cmetric%3E' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listInsightsTimeseries({
      "from": "2026-10-09T09:00:00.000Z",
      "to": "2026-10-09T09:00:00.000Z",
      "metric": "<metric>"
    })
  • Method: GET

    /api/v1/mcp/connection-limits

    Your own remaining spend budget for this credential, right now.

    Rate limit: 60 / minute

    Scope: usage:read

    ›Request examples for get_connection_limits
    curl
    curl -X GET 'https://tonta.media/api/v1/mcp/connection-limits' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getConnectionLimits()
  • Method: GET

    /api/v1/offers/live

    The offers live for your workspace right now — read-only; accept one on the web.

    Rate limit: 30 / minute

    Scope: usage:read

    ›Request examples for list_offers
    curl
    curl -X GET 'https://tonta.media/api/v1/offers/live' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.listOffers()
  • Method: GET

    /api/v1/posts/{scheduledPostId}/analytics

    One published post's latest metrics and their time series.

    Scope: usage:read

    ›Request examples for get_post_analytics
    curl
    curl -X GET 'https://tonta.media/api/v1/posts/<scheduledPostId>/analytics' \
      -H 'Authorization: Bearer '"$TONTA_API_KEY"
    TypeScript
    import { TontaClient } from './tonta-client' // generated from https://tonta.media/api/v1/openapi.json
    
    const client = new TontaClient({
      baseUrl: 'https://tonta.media/api',
      token: process.env.TONTA_API_KEY,
    })
    
    const result = await client.getPostAnalytics({
      "scheduledPostId": "<scheduledPostId>"
    })

Generated from the same contract the server enforces. Paths are under /api; the workspace always comes from your key. Examples show required fields only, with placeholders you replace.

Get an API key

Create and rotate keys from Settings → API keys once you're signed in.

Manage API keys