API and MCP server

The same use cases as the web app — voices, uploads, conversions, narrations and downloads — from your code or from your assistant. The same minutes and the same bill.

Authentication#

Every request carries an API key, either in its own header or as a bearer credential. Both forms work and do exactly the same thing; pick whichever suits your client.

x-api-key — An API key created in Settings → API (miy_…).
bearer — The same API key, as Authorization: Bearer miy_…. An OAuth 2.1 access token is NOT accepted on /v1: it authenticates the MCP server only.

Keys are created in Settings → API. The full key is shown once, when you create it: keep it where you keep your other secrets and never ship it in a client. Revoking one takes effect immediately and erases nothing you already did with it.

Go to Settings → API

The MCP server does not use keys: it authorises with a token your assistant obtains for you. See the MCP server section.

What a key carries

When you create a key you choose its name, the permissions it carries, an optional expiry and, if you want one, a daily overage cap of its own below the general one. A key is never widened afterwards: one that needs more is a new key.

Permissions you can grant it	`voices:readjobs:readjobs:writenarrations:write`
Maximum length of the name, in characters	64
Expiry, optional, in days	1–365
Daily overage cap of the key, optional, in minutes	1–1,440

Access is a right of your plan#

The API and the MCP server are included in the professional plans. If yours does not include them the credential still exists but does not authorise: the answer says so with its own code and a forbidden status.

Losing the plan deletes and revokes nothing. Your keys and your authorisations stay where they were and start working again as soon as the plan does.

There is no sandbox and there are no test keys: every call runs against your real account and every job spends real minutes. Try the flow with a short file first.

The API and the MCP server are part of the service: what you do through them is covered by the same terms and the same privacy policy as your account.

Limits#

Requests are limited per minute, both per calling address and per credential. When you cross a limit, the answer comes back with a too-many-requests status and a header saying how many seconds to wait. Honour it instead of retrying in a loop.

There is also a daily overage cap per credential, in seconds and per calendar day. Once you reach it, an operation that would consume is refused without writing anything: no job is created, no overage is charged, and the next day starts from zero.

Every answer from an operation that consumes carries the estimated split between what comes out of your plan and what would be overage. It is an estimate made up front, not the invoice: the final figure is settled when the job finishes.

Requests per minute from one calling address	300
Requests per minute with one credential	120
Daily overage cap per credential, unless the key sets a lower one	30 minutes
When the daily cap starts over	at midnight, UTC
Header that says how many seconds to wait on a too-many-requests answer	Retry-After

Idempotency#

Operations that create work require an idempotency key that you choose and that must be different for every new attempt. On uploads it is optional, but worth sending.

If a request is cut short by a network failure and you do not know whether it arrived, repeat it with the SAME key: you either get back the work that was already created or it is created then, never twice.

Use the same key for the upload and for the job that confirms it: they are two steps of one intention, and sharing the key is what stops a retry of the first step from creating a second job. Reusing it after confirming IS a conflict, and you are told so with its own code.

Pagination#

Lists are walked with an opaque cursor: ask for the first page, keep the cursor the answer carries and pass it back untouched on the next request. Do not parse it or build one: what is inside is an internal detail and may change.

When the cursor in the answer comes back empty you are done: there are no more pages.

Errors#

Every error, in the API and in the MCP server, arrives in the same shape: a code, a message and a request identifier.

The code is stable and is what your program should read. The full catalogue is below, with the status each one carries.

The message is written for a person and follows the language you ask for in the language header; English when you ask for none. Do not branch on it: change the language and it can be rewritten.

Keep the request identifier. It is the first thing we will ask for if you write to support, and it is what lets us find your exact call among all of them.

If an answer does not add up, write to us with the request identifier at support@makeityours.app, or open the help channel inside the app: Help

The message can come in any of the languages the product speaks; ask for one with the language header using one of these codes:

esenpt-BRdefritpl

Versioning#

The version lives in the path and never changes meaning under you: we do not remove a field, narrow a value or change what an answer means without changing the version.

What we do add — a new operation, a new optional field, a new error code — is announced in the changelog. Anything incompatible would ship under a different version.

See the changelog

Quick start#

From a file on your disk to a downloaded result, in seven steps. Every example comes from the contract: the method, the path, the body and the answer are the ones the real API serves. Replace the key and the idempotency key with your own.

Step 1createUpload

bash

curl -X POST 'https://www.makeityours.app/api/v1/uploads' \
  -H 'x-api-key: miy_…' \
  -H 'Idempotency-Key: <unique-key>' \
  -H 'Content-Type: application/json' \
  --data '{
  "filename": "spring-spot.mp4",
  "sizeBytes": 48213907,
  "contentType": "video/mp4"
}'

Request

json

{
  "filename": "spring-spot.mp4",
  "sizeBytes": 48213907,
  "contentType": "video/mp4"
}

Response · 201

json

{
  "data": {
    "uploadId": "u8p2l4o6a1d3i5n7g9s2t4r6",
    "putUrl": "https://media.makeityours.app/media/u1s3e5r7a9b1c3d5e7f9g1h3/u8p2l4o6a1d3i5n7g9s2t4r6/source.mp4?signature=example",
    "expiresAt": "2026-09-13T11:00:00.000Z",
    "constraints": {
      "maxSizeBytes": 524288000,
      "maxDurationSeconds": 180,
      "containers": [
        "mp4",
        "mov"
      ]
    }
  }
}

2
Step 2
Upload the file to that address in a single request, declaring the same content type you registered it with: it is the type the stored file keeps and the one the download answers with. The request carries none of your credentials: the authorisation travels inside the address itself.
bash
```
curl -X PUT 'https://media.makeityours.app/media/u1s3e5r7a9b1c3d5e7f9g1h3/u8p2l4o6a1d3i5n7g9s2t4r6/source.mp4?signature=example' \
  -H 'Content-Type: video/mp4' \
  --upload-file 'spring-spot.mp4'
```

Step 3runUploadPreflight

Ask for the pre-flight check of the uploaded file. That is what measures the duration and decides whether it can be converted.

bash

curl -X POST 'https://www.makeityours.app/api/v1/uploads/u8p2l4o6a1d3i5n7g9s2t4r6/preflight' \
  -H 'x-api-key: miy_…'

Response · 200

json

{
  "data": {
    "uploadId": "u8p2l4o6a1d3i5n7g9s2t4r6",
    "ready": true,
    "preflight": {
      "container": "mov,mp4,m4a,3gp,3g2,mj2",
      "videoCodec": "h264",
      "hasAudio": true,
      "audioCodec": "aac",
      "containerDurationS": 41.72,
      "audioDurationS": 41.68,
      "vfrSuspected": false,
      "remuxSafe": true
    }
  }
}

Step 4createJob

Confirm the conversion with the voices you want. This is where the minutes are reserved, so this is where the idempotency key is required.

bash

curl -X POST 'https://www.makeityours.app/api/v1/jobs' \
  -H 'x-api-key: miy_…' \
  -H 'Idempotency-Key: <unique-key>' \
  -H 'Content-Type: application/json' \
  --data '{
  "uploadId": "u8p2l4o6a1d3i5n7g9s2t4r6",
  "voiceIds": [
    "v4n8k2m6p1q9s3t7w5x1y2z4",
    "l1a3m5v7o9i2c4e6b8d0f2h4"
  ],
  "name": "Spring spot — Ana and Liam",
  "voiceSettings": {
    "v4n8k2m6p1q9s3t7w5x1y2z4": {
      "similarity": 0.8,
      "stability": 0.45,
      "speakerBoost": true
    }
  }
}'

Request

json

{
  "uploadId": "u8p2l4o6a1d3i5n7g9s2t4r6",
  "voiceIds": [
    "v4n8k2m6p1q9s3t7w5x1y2z4",
    "l1a3m5v7o9i2c4e6b8d0f2h4"
  ],
  "name": "Spring spot — Ana and Liam",
  "voiceSettings": {
    "v4n8k2m6p1q9s3t7w5x1y2z4": {
      "similarity": 0.8,
      "stability": 0.45,
      "speakerBoost": true
    }
  }
}

Response · 202

json

{
  "data": {
    "job": {
      "id": "k7f2q9x1m3p8w5z2c4v6b8n0",
      "status": "queued",
      "steps": [
        {
          "key": "prepare",
          "done": false
        },
        {
          "key": "separate",
          "done": false
        },
        {
          "key": "convert",
          "done": false
        },
        {
          "key": "package",
          "done": false
        },
        {
          "key": "finalize",
          "done": false
        }
      ],
      "variants": [
        {
          "variantId": "r3v5a7r9i1a3n5t7x9y1z3w5",
          "voiceName": "Ana",
          "driftMs": null,
          "hasResult": false,
          "speakers": []
        },
        {
          "variantId": "r4v6a8r0i2a4n6t8x0y2z4w6",
          "voiceName": "Liam",
          "driftMs": null,
          "hasResult": false,
          "speakers": []
        }
      ],
      "variantsTotal": 2,
      "convertVariantsDone": 0,
      "paused": false,
      "isRemaster": false,
      "isNarration": false
    },
    "estimate": {
      "planSeconds": 66,
      "overageSeconds": 18,
      "overageAmountCents": 18,
      "currency": "usd"
    }
  }
}

Step 5

If you have an endpoint registered, you are told the job finished as soon as it does, signed. It is the alternative to polling.

bash

curl -X POST 'https://example.com/webhooks' \
  -H 'MIY-Signature: t=1789293852,v1=<hex HMAC-SHA256 of "t.body" with your endpoint secret>' \
  -H 'Content-Type: application/json' \
  --data '{
  "id": "e5v7e9n1t3a5b7c9d1e3f5g7",
  "type": "job.completed",
  "createdAt": "2026-09-13T10:04:12.000Z",
  "data": {
    "jobId": "k7f2q9x1m3p8w5z2c4v6b8n0",
    "status": "done",
    "kind": "conversion",
    "links": {
      "job": "https://www.makeityours.app/api/v1/jobs/k7f2q9x1m3p8w5z2c4v6b8n0",
      "download": "https://www.makeityours.app/api/v1/jobs/k7f2q9x1m3p8w5z2c4v6b8n0/download"
    }
  }
}'

http

t=1789293852,v1=<hex HMAC-SHA256 of "t.body" with your endpoint secret>

Request

json

{
  "id": "e5v7e9n1t3a5b7c9d1e3f5g7",
  "type": "job.completed",
  "createdAt": "2026-09-13T10:04:12.000Z",
  "data": {
    "jobId": "k7f2q9x1m3p8w5z2c4v6b8n0",
    "status": "done",
    "kind": "conversion",
    "links": {
      "job": "https://www.makeityours.app/api/v1/jobs/k7f2q9x1m3p8w5z2c4v6b8n0",
      "download": "https://www.makeityours.app/api/v1/jobs/k7f2q9x1m3p8w5z2c4v6b8n0/download"
    }
  }
}

Step 6getJob

Read the job whenever you want to know how it is going or which variants it produced.

bash

curl -X GET 'https://www.makeityours.app/api/v1/jobs/j2b4d6f8h0k1m3p5r7t9v1x3' \
  -H 'x-api-key: miy_…'

Response · 200

json

{
  "data": {
    "id": "j2b4d6f8h0k1m3p5r7t9v1x3",
    "status": "done",
    "steps": [
      {
        "key": "prepare",
        "done": true
      },
      {
        "key": "separate",
        "done": true
      },
      {
        "key": "convert",
        "done": true
      },
      {
        "key": "package",
        "done": true
      },
      {
        "key": "finalize",
        "done": true
      }
    ],
    "variants": [
      {
        "variantId": "r3v5a7r9i1a3n5t7x9y1z3w5",
        "voiceName": "Ana",
        "driftMs": 120,
        "hasResult": true,
        "speakers": []
      }
    ],
    "variantsTotal": 1,
    "convertVariantsDone": 1,
    "paused": false,
    "isRemaster": false,
    "isNarration": false
  }
}

7
Step 7downloadJob
Ask for the download with your key and read the redirect header: it points at a temporary address to fetch the file from. Fetch the file with a second command WITHOUT the key — the address carries its own authorisation and expires quickly — and do not let your client follow the redirect while re-sending the key to another server.
bash
```
curl -X GET 'https://www.makeityours.app/api/v1/jobs/j2b4d6f8h0k1m3p5r7t9v1x3/download' \
  -H 'x-api-key: miy_…' \
  -sS -o /dev/null -D -
```
Then, without the key
bash
```
curl -sS -o result.mp4 '<the Location header of the previous answer>'
```

The whole flow in one program

The same seven steps as one runnable file, in Node.js and in Python, with no dependency beyond the standard library. Each one reads your key from an environment variable, takes the video and the voice as arguments, waits for the job and saves the result next to it. Start from here and keep what you need.

javascriptconvert.js

// MakeItYours API - one complete integration: register an upload, PUT the video,
// run the pre-flight, confirm the conversion, wait for it and download the result.
// Node.js 20 or newer, standard library only (global fetch).
//
//   usage: MIY_API_KEY=miy_… node convert.js <video.mp4|.mov> <voiceId>
//
// Pick a voiceId from GET /v1/voices (the shared bank, or ?kind=own for your clones).

const { randomUUID } = require('crypto');
const { readFile, writeFile } = require('fs/promises');
const { basename, extname } = require('path');

const API = 'https://www.makeityours.app/api';
const API_KEY = process.env.MIY_API_KEY;
const POLL_SECONDS = 5;
// A job never leaves one of these: the loop below stops on them.
const TERMINAL_STATUSES = new Set(['done', 'failed', 'cancelled']);
// The contentType declared in step 1. The PUT of step 2 MUST send the same value.
const CONTENT_TYPES = { '.mp4': 'video/mp4', '.mov': 'video/quicktime' };

class ApiError extends Error {
  constructor(status, envelope) {
    const error = envelope && envelope.error ? envelope.error : {};
    super(`${status} ${error.code || 'unknown'}: ${error.message || ''} (requestId ${error.requestId || '?'})`);
    this.status = status;
    this.code = error.code;
    this.requestId = error.requestId;
  }
}

// One call to the API: the key, the optional idempotency key, an optional JSON body.
// Any 4xx/5xx answer becomes an ApiError carrying the code and the requestId of the envelope.
async function call(method, path, { body, idempotencyKey, redirect = 'follow' } = {}) {
  const headers = { 'x-api-key': API_KEY };
  if (idempotencyKey) headers['Idempotency-Key'] = idempotencyKey;
  if (body !== undefined) headers['Content-Type'] = 'application/json';
  const response = await fetch(API + path, {
    method,
    headers,
    body: body === undefined ? undefined : JSON.stringify(body),
    redirect,
  });
  if (response.status >= 400) throw new ApiError(response.status, await response.json().catch(() => null));
  return response;
}

const json = (response) => response.json();
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function main(file, voiceId) {
  if (!API_KEY || !file || !voiceId) {
    console.error('usage: MIY_API_KEY=miy_… node convert.js <video.mp4|.mov> <voiceId>');
    process.exit(2);
  }
  const bytes = await readFile(file);
  const contentType = CONTENT_TYPES[extname(file).toLowerCase()];
  if (!contentType) throw new Error('only .mp4 and .mov files are accepted');
  // ONE idempotency key for the upload AND the job that confirms it (see "Idempotency").
  const idempotencyKey = randomUUID();

  // 1. Register the upload: the answer carries the presigned PUT URL and the limits.
  const upload = await json(await call('POST', '/v1/uploads', {
    body: { filename: basename(file), sizeBytes: bytes.byteLength, contentType },
    idempotencyKey,
  }));
  const { uploadId, putUrl } = upload.data;

  // 2. PUT the bytes. No API key here (the URL carries its own authorisation) and
  //    the SAME Content-Type as step 1: it is the media type the stored file keeps.
  const put = await fetch(putUrl, { method: 'PUT', headers: { 'Content-Type': contentType }, body: bytes });
  if (!put.ok) throw new Error(`upload failed with status ${put.status}`);

  // 3. Pre-flight: measures the duration and decides whether the file can be converted.
  await call('POST', '/v1/uploads/' + uploadId + '/preflight');

  // 4. Confirm the conversion. Minutes are reserved HERE; the estimate says how many.
  const created = await json(await call('POST', '/v1/jobs', {
    body: { uploadId, voiceIds: [voiceId], name: basename(file) },
    idempotencyKey,
  }));
  let job = created.data.job;
  const { planSeconds, overageSeconds } = created.data.estimate;
  console.log(`job ${job.id}: ${job.status} (estimate: ${planSeconds} s from the plan, ${overageSeconds} s of overage)`);

  // 5. Wait. In production a webhook (see "Webhooks") replaces this loop.
  while (!TERMINAL_STATUSES.has(job.status)) {
    await sleep(POLL_SECONDS * 1000);
    job = (await json(await call('GET', '/v1/jobs/' + job.id))).data;
    console.log(`job ${job.id}: ${job.status}`);
  }
  if (job.status !== 'done') throw new Error(`the job ended ${job.status}`);

  // 6. Download: the API answers a redirect to a short-lived URL. Read the Location
  //    WITHOUT following it, then fetch that URL WITHOUT the key.
  const redirect = await call('GET', '/v1/jobs/' + job.id + '/download', { redirect: 'manual' });
  const location = redirect.headers.get('location');
  if (!location) throw new Error(`expected a redirect, got status ${redirect.status}`);
  const result = await fetch(location);
  if (!result.ok) throw new Error(`download failed with status ${result.status}`);
  await writeFile('result.mp4', Buffer.from(await result.arrayBuffer()));
  console.log('saved result.mp4');
}

main(process.argv[2], process.argv[3]).catch((error) => {
  console.error(error instanceof ApiError ? `API error: ${error.message}` : error);
  process.exit(1);
});

pythonconvert.py

"""MakeItYours API - one complete integration: register an upload, PUT the video,
run the pre-flight, confirm the conversion, wait for it and download the result.
Python 3.9 or newer, standard library only.

    usage: MIY_API_KEY=miy_… python3 convert.py <video.mp4|.mov> <voiceId>

Pick a voiceId from GET /v1/voices (the shared bank, or ?kind=own for your clones).
"""
import json
import os
import sys
import time
import uuid
from urllib import error, request

API = "https://www.makeityours.app/api"
API_KEY = os.environ.get("MIY_API_KEY", "")
POLL_SECONDS = 5
# A job never leaves one of these: the loop below stops on them.
TERMINAL_STATUSES = {"done", "failed", "cancelled"}
# The contentType declared in step 1. The PUT of step 2 MUST send the same value.
CONTENT_TYPES = {".mp4": "video/mp4", ".mov": "video/quicktime"}


class ApiError(Exception):
    """A 4xx/5xx answer: the code and the requestId of the envelope."""

    def __init__(self, status, envelope):
        err = (envelope or {}).get("error") or {}
        super().__init__(
            f"{status} {err.get('code', 'unknown')}: {err.get('message', '')} (requestId {err.get('requestId', '?')})"
        )
        self.status = status
        self.code = err.get("code")
        self.request_id = err.get("requestId")


class _NoRedirect(request.HTTPRedirectHandler):
    def redirect_request(self, req, fp, code, msg, headers, newurl):
        return None


def call(method, path, body=None, idempotency_key=None, follow_redirects=True):
    """One call to the API: the key, the optional idempotency key, an optional JSON body."""
    headers = {"x-api-key": API_KEY}
    if idempotency_key:
        headers["Idempotency-Key"] = idempotency_key
    data = None
    if body is not None:
        headers["Content-Type"] = "application/json"
        data = json.dumps(body).encode("utf-8")
    req = request.Request(API + path, data=data, method=method, headers=headers)
    opener = request.build_opener() if follow_redirects else request.build_opener(_NoRedirect)
    try:
        with opener.open(req) as response:
            return response.status, response.headers, response.read()
    except error.HTTPError as exc:
        payload = exc.read()
        if 300 <= exc.code < 400:
            return exc.code, exc.headers, payload
        try:
            envelope = json.loads(payload)
        except ValueError:
            envelope = None
        raise ApiError(exc.code, envelope) from None


def call_json(method, path, **kwargs):
    _, _, payload = call(method, path, **kwargs)
    return json.loads(payload)


def main(file, voice_id):
    if not API_KEY or not file or not voice_id:
        print("usage: MIY_API_KEY=miy_… python3 convert.py <video.mp4|.mov> <voiceId>", file=sys.stderr)
        sys.exit(2)
    with open(file, "rb") as handle:
        data = handle.read()
    content_type = CONTENT_TYPES.get(os.path.splitext(file)[1].lower())
    if not content_type:
        raise SystemExit("only .mp4 and .mov files are accepted")
    # ONE idempotency key for the upload AND the job that confirms it (see "Idempotency").
    idempotency_key = str(uuid.uuid4())

    # 1. Register the upload: the answer carries the presigned PUT URL and the limits.
    upload = call_json(
        "POST",
        "/v1/uploads",
        body={"filename": os.path.basename(file), "sizeBytes": len(data), "contentType": content_type},
        idempotency_key=idempotency_key,
    )
    upload_id, put_url = upload["data"]["uploadId"], upload["data"]["putUrl"]

    # 2. PUT the bytes. No API key here (the URL carries its own authorisation) and
    #    the SAME Content-Type as step 1: it is the media type the stored file keeps.
    put = request.Request(put_url, data=data, method="PUT", headers={"Content-Type": content_type})
    with request.urlopen(put) as response:
        if response.status >= 300:
            raise SystemExit(f"upload failed with status {response.status}")

    # 3. Pre-flight: measures the duration and decides whether the file can be converted.
    call("POST", "/v1/uploads/" + upload_id + "/preflight")

    # 4. Confirm the conversion. Minutes are reserved HERE; the estimate says how many.
    created = call_json(
        "POST",
        "/v1/jobs",
        body={"uploadId": upload_id, "voiceIds": [voice_id], "name": os.path.basename(file)},
        idempotency_key=idempotency_key,
    )
    job = created["data"]["job"]
    estimate = created["data"]["estimate"]
    print(f"job {job['id']}: {job['status']} (estimate: {estimate['planSeconds']} s from the plan, {estimate['overageSeconds']} s of overage)")

    # 5. Wait. In production a webhook (see "Webhooks") replaces this loop.
    while job["status"] not in TERMINAL_STATUSES:
        time.sleep(POLL_SECONDS)
        job = call_json("GET", "/v1/jobs/" + job["id"])["data"]
        print(f"job {job['id']}: {job['status']}")
    if job["status"] != "done":
        raise SystemExit(f"the job ended {job['status']}")

    # 6. Download: the API answers a redirect to a short-lived URL. Read the Location
    #    WITHOUT following it, then fetch that URL WITHOUT the key.
    status, headers, _ = call("GET", "/v1/jobs/" + job["id"] + "/download", follow_redirects=False)
    location = headers.get("Location")
    if not location:
        raise SystemExit(f"expected a redirect, got status {status}")
    with request.urlopen(location) as result, open("result.mp4", "wb") as out:
        out.write(result.read())
    print("saved result.mp4")


if __name__ == "__main__":
    try:
        main(sys.argv[1] if len(sys.argv) > 1 else None, sys.argv[2] if len(sys.argv) > 2 else None)
    except ApiError as exc:
        print(f"API error: {exc}", file=sys.stderr)
        sys.exit(1)

Voices#

There are two families of voices: the bank, shared by everyone, and your own. The answer says which family each one belongs to, and only you ever see yours.

Every voice carries a link to a sample so you can listen before spending minutes. Reading one of your own active voices for the first time GENERATES its sample during that very request — a real reading of the voice, made once and kept — so the answer takes a moment and already carries the link.

An empty sample means the voice is not active, or that generating it failed. Nothing is lost: the answer is still complete, and a later request tries again once a short wait has passed.

The script read in that sample is in the language of the account that owns the voice; when the account has none set, in the language you ask for in the language header; and in Spanish when neither says. Because the sample is made once and kept, the language in force at the request that generates it is the one that sticks.

Bank facets

The bank is filtered by these facets. The codes never change; what changes with the language is the word you read.

language (Facet): arArabicdeGermanenEnglishesSpanishfrFrenchhiHindiitItalianjaJapanesekoKoreannlDutchplPolishptPortugueseroRomaniansvSwedishtrTurkishzhChinese
accent (Facet): americanAmericanandalusianAndalusianargentineArgentineaustralianAustralianaustrianAustrianbavarianBavarianbelgianBelgianbrazilianBrazilianbritishBritishcanadianCanadiancastilianCastiliancatalanCatalanchileanChileancolombianColombiancubanCubaneuropeanEuropeanfilipinoFilipinofrenchFrenchgalicianGaliciangermanGermanindianIndianirishIrishitalianItalianjamaicanJamaicanlatin-americanLatin AmericanmexicanMexicanneutralneutralnew-zealandNew ZealandnigerianNigerianparisianParisianperuvianPeruvianpuerto-ricanPuerto RicanquebecoisQuebecoisscottishScottishsingaporeanSingaporeansouth-africanSouth AfricanspanishSpanishstandardstandardswedishSwedishswissSwisstransatlanticTransatlantictuscanTuscanus-southernUS SouthernvenezuelanVenezuelanwelshWelsh
age (Facet): youngyoungadultadultseniorsenior
gender (Facet): femalefemalemalemaleneutralneutral
useCase (Facet): advertisementadvertisingasmrASMRaudiobookaudiobookscharacterscharactersconversationalconversationeducationaleducational contententertainmententertainmentmeditationmeditationnarrationnarrationnewsnewssocial-mediasocial media

Conversions#

Creating a conversion returns a job with a status you read until it finishes. The possible statuses travel in the schema, and they are the same ones you see in the web app.

A job walks these statuses in this order. The last three are final: once there, it never changes again.

confirmed
queued
processing
done(final)
failed(final)
cancelled(final)

If you poll instead of receiving a webhook, read the job no more often than this: 5 seconds

Cancelling is an order, not an immediate effect: the request is accepted and the cancellation happens afterwards. Read the job again to find out whether it arrived in time. If it is cancelled before finishing, the reserved minutes go back to your balance.

Several voices in one video#

When several characters talk in your video, each one can sound with its own voice. The upload is analysed to tell the speakers apart, and the conversion takes a voice for each speaker.

After the pre-flight of the upload, request the speaker detection. It runs in the background, and requesting it again changes nothing.
Read the detection until it is no longer running. Once it is ready, each speaker comes with the stretches in which it talks and a short clip of its own voice to recognise it.
Create the conversion from that upload saying, for each variant, which voice each speaker takes. The first speaker always keeps the variant voice, and so does any speaker you leave out.

A detection walks these statuses; every one but the first is final:

pending
ready(final)
single(final)
too_many(final)
failed(final)

The detection consumes no minutes, and a conversion with several voices costs exactly what it costs with one: what counts is the length of the video, not the number of voices.

If the several-voices feature is not available to your account at that moment, or the detection is not ready, the conversion is refused with its code: it is never converted with one voice instead. If a detection is still running after a long while, convert with one voice.

A conversion that reuses the video of another one has no detection of its own: for several voices, upload the video again.

jsonA ready detection

{
  "data": {
    "speakers": [
      {
        "index": 0,
        "previewUrl": "https://media.makeityours.app/media/u1s3e5r7a9b1c3d5e7f9g1h3/u8p2l4o6a1d3i5n7g9s2t4r6/speaker-0.m4a?signature=example",
        "segments": [
          {
            "endMs": 12300,
            "startMs": 0
          },
          {
            "endMs": 41680,
            "startMs": 28640
          }
        ],
        "totalMs": 25340
      },
      {
        "index": 1,
        "previewUrl": "https://media.makeityours.app/media/u1s3e5r7a9b1c3d5e7f9g1h3/u8p2l4o6a1d3i5n7g9s2t4r6/speaker-1.m4a?signature=example",
        "segments": [
          {
            "endMs": 28640,
            "startMs": 12300
          }
        ],
        "totalMs": 16340
      }
    ],
    "status": "ready",
    "uploadId": "u8p2l4o6a1d3i5n7g9s2t4r6"
  }
}

jsonA conversion with another voice for one speaker

{
  "name": "Spring spot — two characters",
  "speakers": [
    {
      "assignments": [
        {
          "speaker": 1,
          "voiceId": "l1a3m5v7o9i2c4e6b8d0f2h4"
        }
      ],
      "variantVoiceId": "v4n8k2m6p1q9s3t7w5x1y2z4"
    }
  ],
  "uploadId": "u8p2l4o6a1d3i5n7g9s2t4r6",
  "voiceIds": [
    "v4n8k2m6p1q9s3t7w5x1y2z4"
  ]
}

The MCP server still converts with one voice per variant: several voices is, for now, an API feature.

Download#

The download does not return the file: it returns a redirect to a temporary address to fetch it from. That address belongs to another server and carries its own authorisation: fetch from it WITHOUT re-sending your key (many clients, curl included, forward custom headers when following a redirect) and do not store it, as it expires within minutes.

The same operation serves the converted video, its audio extract, one separated track or the narration: which one is a query parameter, documented in the reference below, and the video is what you get when you say nothing.

When a job has several variants — because you asked for several voices or several tracks — you have to say which one you want: without it there is no right answer and the request is refused. Reading the job tells you which ones exist.

Every file you download carries the marking for content generated with artificial intelligence that European law requires. Removing it is forbidden by the terms of service.

Narrations#

Narrating a script with one of your usable voices creates a job just like a conversion: you read it and download it through the same operations.

The answer says the request has been ACCEPTED, not that the job is already queued: queuing happens right afterwards. If the answer never reaches you, or you doubt it was registered, repeat the request with the same idempotency key; it will not be duplicated.

Webhooks#

If you would rather not poll a job for its status, register an endpoint in Settings and we will tell you when it finishes. The list of events and the exact shape of each one are below.

Go to Settings → Webhooks

Deliveries do not come from a fixed set of addresses, so do not allow-list by source: the signature is what proves a delivery is ours.

job.completed

A job finished successfully

Delivered to every enabled endpoint of yours subscribed to job.completed. Verify MIY-Signature (t=<unix seconds>,v1=<hex HMAC-SHA256 of "t.body" with your endpoint secret>, tolerance 300 s) before trusting the body. Answer any 2xx; anything else is retried — 8 attempts in all, waiting 1 min, 5 min, 15 min, 1 h, 4 h, 12 h and 24 h between them — and given up after the last one.

MIY-Signature — Signature of the delivery: t=<unix seconds>,v1=<hex>.

WebhookEvent

json

{
  "createdAt": "2026-09-13T10:04:12.000Z",
  "data": {
    "jobId": "k7f2q9x1m3p8w5z2c4v6b8n0",
    "kind": "conversion",
    "links": {
      "download": "https://www.makeityours.app/api/v1/jobs/k7f2q9x1m3p8w5z2c4v6b8n0/download",
      "job": "https://www.makeityours.app/api/v1/jobs/k7f2q9x1m3p8w5z2c4v6b8n0"
    },
    "status": "done"
  },
  "id": "e5v7e9n1t3a5b7c9d1e3f5g7",
  "type": "job.completed"
}

job.failed

A job failed or was cancelled

Delivered to every enabled endpoint of yours subscribed to job.failed. Verify MIY-Signature (t=<unix seconds>,v1=<hex HMAC-SHA256 of "t.body" with your endpoint secret>, tolerance 300 s) before trusting the body. Answer any 2xx; anything else is retried — 8 attempts in all, waiting 1 min, 5 min, 15 min, 1 h, 4 h, 12 h and 24 h between them — and given up after the last one.

MIY-Signature — Signature of the delivery: t=<unix seconds>,v1=<hex>.

WebhookEvent

json

{
  "createdAt": "2026-09-13T10:04:12.000Z",
  "data": {
    "jobId": "f4a6i8l0e2d4j6o8b0c2d4e6",
    "kind": "conversion",
    "links": {
      "download": null,
      "job": "https://www.makeityours.app/api/v1/jobs/f4a6i8l0e2d4j6o8b0c2d4e6"
    },
    "status": "failed"
  },
  "id": "e6v8e0n2t4a6b8c0d2e4f6g8",
  "type": "job.failed"
}

Verifying the signature

Every delivery carries a signature header with a timestamp and a digest computed with your endpoint secret over the timestamp, a dot and the EXACT body you received. Compute yours over the bytes as they arrive, without re-serialising the JSON, and compare in constant time. Reject the delivery when the timestamp falls outside the tolerance, even if the digest matches.

The header may carry more than one digest while you rotate the secret: accept the delivery if any of them matches.

javascript

const { createHmac, timingSafeEqual } = require('node:crypto');

const SIGNATURE_HEADER = 'MIY-Signature';
const SCHEME = 'v1';
const TOLERANCE_SECONDS = 300;

// `header` is the value of SIGNATURE_HEADER. `body` MUST be the raw payload you
// received, as a string: re-serialising the parsed JSON changes the bytes, and a
// different byte is a different signature.
function verify(header, body, secret, nowSeconds) {
  if (typeof header !== 'string' || header === '') return false;

  // `t` is kept TWICE: as the header wrote it (the bytes the sender signed over)
  // and as a number (for the clock). Re-serialising it would be the same mistake
  // as re-serialising the body.
  let timestampText = null;
  let timestamp = null;
  const signatures = [];
  for (const part of header.split(',')) {
    const eq = part.indexOf('=');
    if (eq <= 0) continue;
    const name = part.slice(0, eq).trim();
    const value = part.slice(eq + 1).trim();
    if (name === 't') {
      if (!/^[0-9]{1,15}$/.test(value)) return false;
      timestampText = value;
      timestamp = Number(value);
    } else if (name === SCHEME) {
      // Several entries are allowed while a secret is being rotated.
      signatures.push(value);
    }
  }
  if (timestamp === null || signatures.length === 0) return false;

  const expected = createHmac('sha256', secret).update(timestampText + '.' + body).digest('hex');
  const expectedBytes = Buffer.from(expected, 'hex');
  const matches = signatures.some((candidate) => {
    const candidateBytes = Buffer.from(candidate, 'hex');
    if (candidateBytes.length !== expectedBytes.length) return false;
    return timingSafeEqual(candidateBytes, expectedBytes);
  });
  if (!matches) return false;

  // Signature first, clock second: a tampered body is a forgery, a well-signed
  // old one is merely late — and only the second is worth a different log line.
  return Math.abs(nowSeconds - timestamp) <= TOLERANCE_SECONDS;
}

module.exports = { verify };

python

import hashlib
import hmac

SIGNATURE_HEADER = "MIY-Signature"
SCHEME = "v1"
TOLERANCE_SECONDS = 300


def verify(header, body, secret, now_seconds):
    """`body` is the raw payload as bytes. Never re-serialise the parsed JSON."""
    if not header:
        return False

    # `t` is kept twice: as the header wrote it (the bytes the sender signed
    # over) and as a number (for the clock). Re-serialising it would be the same
    # mistake as re-serialising the body.
    timestamp_text = None
    timestamp = None
    signatures = []
    for part in header.split(","):
        name, _, value = part.partition("=")
        name, value = name.strip(), value.strip()
        if name == "t":
            # `str.isdigit()` alone accepts Arabic-Indic and other non-ASCII
            # digits, which `int()` then happily parses: the Node twin bounds
            # the same field with `[0-9]{1,15}` and this has to agree.
            if not (value.isascii() and value.isdigit()) or len(value) > 15:
                return False
            timestamp_text = value
            timestamp = int(value)
        elif name == SCHEME:
            # Several entries are allowed while a secret is being rotated.
            signatures.append(value)
    if timestamp is None or not signatures:
        return False

    expected = hmac.new(
        secret.encode("utf-8"),
        (timestamp_text + ".").encode("utf-8") + body,
        hashlib.sha256,
    ).hexdigest()
    # `compare_digest` RAISES on two `str` with a non-ASCII character in them,
    # and `candidate` comes straight from the request: a stray byte in the header
    # must be a rejected delivery, not a crashed handler. The Node twin reaches the
    # same verdict through `Buffer.from(candidate, "hex")`.
    if not any(
        candidate.isascii() and hmac.compare_digest(candidate, expected)
        for candidate in signatures
    ):
        return False

    # Signature first, clock second.
    return abs(now_seconds - timestamp) <= TOLERANCE_SECONDS

Retries

Answer with any success status and answer fast: queue the work on your side and reply, do not process before replying. Anything else — or nothing — makes us retry with these waits, and after the last one the delivery is given up.

Attempt	Wait before the next one
1	1 minute
2	5 minutes
3	15 minutes
4	1 hour
5	4 hours
6	12 hours
7	24 hours
8	None

When several attempts in a row fail we email you, once, so an endpoint that went down does not stay down unnoticed. Delivering again clears it.

A delivery to an endpoint you have disabled, or made while your plan does not include the API, is neither attempted nor given up: it is held, re-examined periodically, and delivered once the endpoint is enabled or the plan is back. Deliveries that reached their last attempt are kept for a while so you can see what failed.

From Settings you can send yourself a test event. It is signed exactly like a real one, but it is NOT part of the contract: its type is not in the list of events and you should not write logic that depends on it.

MCP server#

The MCP server lets an assistant use your account on your behalf: list voices, start an upload, create a conversion or a narration and read how it is going. They are the same operations as the API, with the same plan, limit and idempotency rules.

textServer address

https://www.makeityours.app/api/mcp

textProtected resource metadata

https://www.makeityours.app/.well-known/oauth-protected-resource

Permissions that can be requested

voices:readjobs:readjobs:writenarrations:writewebhooks:manageoffline_access

webhooks:manage — reserved: no operation or tool requires it yet.

Adding it to your assistant

Assistants that speak this protocol are all set up the same way: add a remote server with its address and authorise in the browser. Menu names move between versions; the path is always this one.

The same path in every assistant

Open the assistant settings and find the section for connectors or external servers.
Choose to add a remote server (not a local one and not a command).
Paste the server address shown above.
Accept when it sends you to the browser to sign in and authorise.
Go back to the assistant and check that the tools show up in its list.

Claude

In Claude, on the web and in the desktop app, the server is a custom connector: open the settings, find the connectors section, choose to add a custom connector and paste the address.

In Claude Code one command adds it; the /mcp command then opens the browser to authorise it:

bash

claude mcp add --transport http makeityours https://www.makeityours.app/api/mcp

Cursor

In Cursor the server goes in the MCP configuration file, in the project or in your home directory. Paste this; Cursor sends you to the browser the first time it connects:

json.cursor/mcp.json

{
  "mcpServers": {
    "makeityours": {
      "url": "https://www.makeityours.app/api/mcp"
    }
  }
}

ChatGPT

In ChatGPT, custom servers are added as connectors from the settings, in the section for developers; the exact menu depends on your plan. Paste the address and authorise in the browser.

The authorisation, from the inside

Nothing has to be registered up front: the assistant registers itself the first time, and the authorisation uses the challenge exchange the protocol requires. All you see is the consent screen in the browser, with the client name and the permissions it asks for.

Returns a short-lived download URL of the result (video, audio extract, a single track or the narration) and when it expires. It does not redirect. The result is synthetic content, marked as such (AI Act).

Get a short-lived download URL of a result (no redirect).

downloadJobScope: jobs:readIdempotency key: No

Result

dataRequiredDownloadUrlResult

Possible errors

rate_limited api_disabled unauthorized auth_email_not_verified api_access_required insufficient_scope invalid_request not_found not_configured download_unavailable unavailable

`create_upload`Start an upload

Starts an upload and returns the URL to PUT the file to, its limits and when it expires. Then call create_conversion with the uploadId. The result is synthetic content, marked as such (AI Act).

Start an upload and get the PUT URL.

createUploadScope: jobs:writeIdempotency key: Yes

Result

CreateUploadResponse

Possible errors

rate_limited api_disabled unauthorized auth_email_not_verified api_access_required insufficient_scope invalid_request idempotency_conflict rejected not_configured upload_unavailable unavailable

Reference#

Generated from the contract: what is here is exactly what the API validates and answers.

Version: 1.1.0Base address: https://www.makeityours.app/api

voices:readjobs:readjobs:writenarrations:writewebhooks:manage

webhooks:manage — reserved: no operation or tool requires it yet.

The document this page is rendered from is also served as a file, without a credential, so you can generate a typed client or load it in your own viewer. Download the OpenAPI document https://www.makeityours.app/api/openapi.json

voices

GET`/v1/voices`

List voices

Lists the shared voice bank (default) or your own cloned voices (kind=own). Every item carries kind: a bank voice is the full Voice shape, one of your clones is the smaller OwnVoice (id, name, status). Bank filters take the stable codes served by GET /v1/voices/facets. The bank is paginated by cursor, newest first, and may change between pages: a voice retired meanwhile simply stops appearing, and a voice added to the bank while you page sits above every cursor, so it shows up on your next full pass, not in the current one. A nextCursor is bound to the FILTERS it was minted under, so replaying it with a different set of filters answers 400 invalid_cursor instead of paging a different sequence. With kind=own the list is your live clones (active and recycled) returned COMPLETE in one response: nextCursor is always null, and cursor, limit and the facet filters are not applied — they are still validated, so an out-of-range value answers 400 invalid_request with either kind.

Scope: voices:readlistVoices

Query

kindOptional
stringEnum"bank""own"Default: "bank"
bank (default) lists the shared bank; own lists your own clones (complete, unpaginated).
languageOptional
stringEnum"ar""de""en""es""fr""hi""it""ja""ko""nl""pl""pt""ro""sv""tr""zh"
accentOptional
stringEnum"american""andalusian""argentine""australian""austrian""bavarian""belgian""brazilian""british""canadian""castilian""catalan""chilean""colombian""cuban""european""filipino""french""galician""german""indian""irish""italian""jamaican""latin-american""mexican""neutral""new-zealand""nigerian""parisian""peruvian""puerto-rican""quebecois""scottish""singaporean""south-african""spanish""standard""swedish""swiss""transatlantic""tuscan""us-southern""venezuelan""welsh"
ageOptional
stringEnum"young""adult""senior"
genderOptional
stringEnum"female""male""neutral"
useCaseOptional
stringEnum"advertisement""asmr""audiobook""characters""conversational""educational""entertainment""meditation""narration""news""social-media"
cursorOptionalstringMinimum length: 1Maximum length: 256Opaque cursor of the next page, from nextCursor. A cursor of another list answers 400 invalid_cursor.
limitOptionalintegerDefault: 20Minimum: 1Maximum: 100Page size, 1–100 (default 20).

Headers

Accept-LanguageOptionalstringLanguage of error.message and of the voice labels (gender, accent, ageRange, language, useCase, description), negotiated as on the website; en when absent or unsupported. Codes, field names and error.code never vary with it.

Responses

200One page of voices.

VoiceListResponse

Example: bank — The shared bank (the default): one page, nextCursor to continue.

json

{
  "data": [
    {
      "accent": "Castilian Spanish",
      "accentCode": "castilian",
      "ageCode": "adult",
      "ageRange": "Adult",
      "description": "Warm, close adult female voice in Castilian Spanish, for advertisements.",
      "gender": "Female",
      "genderCode": "female",
      "id": "v4n8k2m6p1q9s3t7w5x1y2z4",
      "kind": "bank",
      "language": "Spanish",
      "languageCode": "es",
      "name": "Ana",
      "sampleText": "Hi, I am Ana. This is how your ad sounds with my voice.",
      "useCase": "Advertisement",
      "useCaseCode": "advertisement"
    },
    {
      "accent": "British English",
      "accentCode": "british",
      "ageCode": "young",
      "ageRange": "Young",
      "description": "Clear, energetic young male voice in British English, for narration.",
      "gender": "Male",
      "genderCode": "male",
      "id": "l1a3m5v7o9i2c4e6b8d0f2h4",
      "kind": "bank",
      "language": "English",
      "languageCode": "en",
      "name": "Liam",
      "sampleText": "Hi, I am Liam. This is how your ad sounds with my voice.",
      "useCase": "Narration",
      "useCaseCode": "narration"
    }
  ],
  "nextCursor": "eyJsIjoidm9pY2VzIiwiYyI6IjIwMjYtMDktMTJUMTg6MzA6MDAuMDAwWiIsImkiOiJsMWEzbTV2N285aTJjNGU2YjhkMGYyaDQifQ"
}

Example: own — Your own clones (kind=own): complete in one response, nextCursor always null.

json

{
  "data": [
    {
      "id": "o1w3n5v7o9i1c2e4b6d8f0h2",
      "kind": "own",
      "name": "My voice",
      "status": "active"
    }
  ],
  "nextCursor": null
}

400Error codes: - invalid_request: The body, query, path or headers do not match the schema of the operation (a path id that is not a cuid2 included). Fix the request; do not retry it unchanged. - invalid_cursor: The cursor is not one this list issued: malformed, or minted for another list. Restart from the first page.

Code	Status	Description
account_closing	409	The account requested its deletion; no new jobs can be created while it closes.
api_access_required	403	The plan of the account does not include API access (a Pro or Agency right). Credentials start working again as soon as the plan does.
api_daily_overage_cap	402	This credential reached its daily overage cap (UTC day). Nothing was written; retry after midnight UTC or raise the cap in Settings.
api_disabled	503	The public API is switched off for now. Retry later; nothing was revoked.
auth_email_not_verified	403	The account owning the credential has not confirmed its email address, so it cannot create jobs.
download_unavailable	500	The download link could not be prepared (our side). Retry.
enqueue_failed	500	The job could not be handed to the queue (our side). Retry.
idempotency_conflict	409	The `Idempotency-Key` was already used with a different request, or with an upload that has since been confirmed into a job. Use a new key.
idempotency_key_required	400	The operation requires an `Idempotency-Key` header and none was sent.
insufficient_scope	403	The credential does not carry the scope this operation requires (`x-scope`).
invalid_cursor	400	The `cursor` is not one this list issued: malformed, or minted for another list. Restart from the first page.
invalid_request	400	The body, query, path or headers do not match the schema of the operation (a path id that is not a cuid2 included). Fix the request; do not retry it unchanged.
invalid_script	422	The `script` is outside its length bounds after trimming, or carries no visible text.
invalid_state	409	The job is not in a state that admits the operation.
invalid_tune	422	A `voiceSettings` value is outside the documented range.
invalid_voices	422	One or more of `voiceIds`, or of the voices in `speakers`, cannot be used for this job (unknown, not yours, retired or not usable right now).
job_not_cancellable	409	The job is already done, failed or cancelled; there is nothing left to cancel.
mcp_disabled	503	The MCP server is switched off for now. Retry later; nothing was revoked.
multi_voice_disabled	403	The several-voices feature is not available to this account right now: it is switched off for the moment, the plan does not include it, or the account has no open billing period at this instant (a renewal in progress — retry in a while). Nothing was written. A job without `speakers` still converts with one voice per variant.
narration_disabled	503	Narration is switched off for now. Retry later.
not_configured	503	The environment is missing a piece of configuration (our side). Retry later.
not_confirmable	409	The upload cannot be turned into a job: its draft is gone or was already confirmed.
not_found	404	The resource does not exist or is not yours. The two cases are deliberately indistinguishable.
overage_unavailable_currency	422	The job would need overage minutes and overage is billed in US dollars only, which is not the billing currency of this account. Stay within the plan allowance.
preflight_unavailable	500	The file could not be analysed (our side). Retry.
rate_limited	429	Too many requests from this IP or credential. Wait the seconds in `Retry-After`, then retry.
rejected	422	The file was refused by the pre-flight: unsupported container, no video or audio track, too long or too large. `error.reason` says which — the closed `ApiErrorReason` enum — and `message` says the same thing in the negotiated language.
speakers_mismatch	400	The `speakers` of the request are malformed or do not fit: not a list of `{ variantVoiceId, assignments }`, a voice id that is not a cuid2, more entries or assignments than allowed, a `variantVoiceId` that is not in `voiceIds` or is listed twice, a speaker listed twice, speaker 0 (it always keeps the voice of its variant), or a speaker the detection of the upload did not find. Fix the request; do not retry it unchanged.
speakers_not_ready	409	The upload has no finished speaker detection with several speakers: it was never requested, or it stopped without an outcome (request it with `POST /v1/uploads/{id}/speakers` — a stopped detection is retried once), it is still `pending`, or its outcome is `single`, `too_many` or `failed`. A job created from a previous job (`sourceJobId`) never has one: upload the video again. Otherwise create the job without `speakers`, or wait for `ready`.
subscription_paused	409	The plan is paused (a billing incident); no new jobs until billing resumes.
unauthorized	401	No usable credential: the API key or access token is missing, malformed, revoked or expired.
unavailable	500	An unexpected failure on our side. Retry with backoff; quote `requestId` to support if it persists.
upload_expired	409	The resumable upload can no longer be resumed: its parts expired or it was discarded. Start the upload again. Reserved for the resumable upload, which is not on `/v1` yet: no `/v1` operation answers it today.
upload_not_ready	409	The upload is not ready for this step: on the pre-flight, the PUT has not completed; on a job, the upload has not been pre-flighted yet.
upload_unavailable	500	The upload could not be registered (our side). Retry.
voice_not_usable	422	The `voiceId` cannot narrate (unknown, not yours, or not usable right now).
voice_service_paused	503	Voice processing is temporarily paused. Retry later.

Authentication#

What a key carries

Access is a right of your plan#

Limits#

Idempotency#

Pagination#

Errors#

Versioning#

Quick start#

Step 1createUpload

Step 2

Step 3runUploadPreflight

Step 4createJob

Step 5

Step 6getJob

Step 7downloadJob

The whole flow in one program

Voices#

Bank facets

Conversions#

Several voices in one video#

Download#

Narrations#

Webhooks#

job.completed

job.failed

Verifying the signature

Retries

MCP server#

Adding it to your assistant

The same path in every assistant

Claude

Cursor

ChatGPT

The authorisation, from the inside

Available tools

list_voicesList voices

get_voiceGet a voice

list_jobsList conversions

get_jobGet a conversion

create_conversionCreate a conversion

create_narrationCreate a narration

get_download_urlGet the download URL

create_uploadStart an upload

Reference#

voices

Query

Headers

Responses

Possible errors

Headers

Responses

Possible errors

Path

Headers

Responses

Possible errors

uploads

Headers

Request body

Responses

Possible errors

Path

Headers

Responses

Possible errors

Path

Headers

Responses

Possible errors

Path

Headers

Responses

Possible errors

jobs

Query

Headers

Responses

Possible errors

Headers

`list_voices`List voices

`get_voice`Get a voice

`list_jobs`List conversions

`get_job`Get a conversion

`create_conversion`Create a conversion

`create_narration`Create a narration

`get_download_url`Get the download URL

`create_upload`Start an upload