MCP integration

Give an AI application access to your TikTok transcript workflow through Model Context Protocol. The remote MCP endpoint exposes tools to create a transcript, retrieve a result, and list recent jobs. It connects to the same account, processing queue, and credit balance as the REST API.

The integration is designed for clients that can connect to a remote Streamable HTTP server and attach an Authorization header. Use a dedicated API key for each client so you can revoke one connection without disrupting your other applications. The server does not require a local transcription process or a separate model installation.

Connection details

The connection is stateless. The server returns each tool response as JSON and does not require an MCP session identifier. Transcript jobs themselves are durable and continue processing independently of the client connection. Closing an agent conversation does not cancel a job already submitted.

The endpoint does not provide a standalone server-sent event stream. A GET request returns HTTP 405; normal tool requests use POST. This is different from the older HTTP+SSE transport. If a client asks for an SSE URL, choose its Streamable HTTP option instead.

Create a dedicated key

Sign in to TikTok Transcript API, open API Keys, and create a key named for the client you are connecting. Copy it when it is first shown and save it in your client's protected credential settings.

Keys are account credentials. The client holding a key can create transcripts and access the account's transcript results. Keep personal and shared team integrations separate when they should not have access to the same material. Do not embed a real key in a configuration file that will be committed publicly or distributed to other people.

A new verified account includes 100 free credits, so you can test a connection before subscribing. Checking tool availability, reading a job, and listing recent jobs do not use transcript credits. Creating a new transcript reserves one credit, which is used on success and released on failure.

Configure your client

Many developer tools accept a configuration similar to the following. The exact file and property names depend on the client. Use its remote HTTP server settings and verify that it supports custom authentication headers.

{
  "mcpServers": {
    "tiktok-transcript": {
      "url": "https://tiktoktranscriptapi.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Replace YOUR_API_KEY in the client's secret field or supported environment-variable interpolation. The literal placeholder will return HTTP 401. Avoid placing the key in the server URL: query strings may be retained in logs and browser history.

After saving the connection, ask the client to refresh or discover its tools. The server should offer create_transcript, get_transcript, and list_transcripts. If no tools appear, check the transport, exact endpoint, header name, and key validity before testing with a video.

This server currently uses static bearer keys and does not expose an OAuth authorization flow. A host that only accepts OAuth-based remote connectors cannot connect directly with these settings. Use a key-capable MCP host or call the REST API from your own application. Do not assume that a generic configuration example guarantees compatibility with every version of a named AI client.

Available tools

create_transcript

Submit one public TikTok video. The response contains a job ID and the status URL. The tool reserves one account credit for a new job and covers up to 20 minutes of audio.

{
  "url": "https://www.tiktok.com/@creator/video/VIDEO_ID",
  "idempotency_key": "research-project-video-001"
}

The same idempotency key and URL return the existing job instead of starting another one. A reused key with a different URL is rejected. Generate the key before the tool call when you need retry safety, and retain it along with the resulting job ID.

The source must be an individual public video. The tool does not search TikTok, inspect account feeds, retrieve comments, or discover related videos. Give the agent an exact video URL selected by the user or by an authorized source in your own application.

get_transcript

Retrieve the current state and result of a job belonging to this account. Pass the identifier returned by create_transcript.

{
  "id": "aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee"
}

A job can be processing, completed, or failed. A completed result includes readable text and segment timestamps. A failed result explains that processing could not finish and releases the reservation. The status read itself does not consume a transcript credit.

Wait at least three seconds between checks. Keep polling bounded so an agent does not loop indefinitely. If the job is still processing at the end of an interactive session, save its ID and check again later. Do not create another transcript just to check progress.

list_transcripts

Retrieve recent jobs, newest first. The optional limit defaults to 20 and accepts integers from 1 through 100.

{
  "limit": 10
}

The list contains job IDs, source URLs, creation timestamps, and the latest synchronized statuses. It does not return full transcript text. Use get_transcript for a current status and completed result. An empty list means the account does not yet have matching recent work; it is not a connection failure.

This tool gives the agent visibility into recent account activity. When connecting a shared AI workspace, consider whether every person using that connection should be able to access the account's transcripts. A separate account is appropriate when data ownership needs to be separate.

A useful agent workflow

A transcript-based research task starts with the user's authorized source URL and a clear output request. For example:

Transcribe this public TikTok video that I created. When it is ready, identify the opening hook, summarize the main explanation, and include timestamps for the strongest quotes.

The agent submits the video through create_transcript and retains the returned ID. While processing continues, it should communicate a pending state. Once get_transcript returns a completed result, the agent can analyze the text and refer to segment times.

The transcript service returns speech text; the AI host performs the summary, comparison, or analysis. A summary is not an additional API output field. If you need repeatable formatting, specify the structure in your application and validate the agent's output before displaying or storing it.

For caption drafting, ask the host to preserve the speaker's meaning and distinguish verbatim text from rewritten captions. For research, ask it to keep quotes separate from its own interpretation. The underlying transcript and source timestamps provide a way to check the result.

Example prompts

Review your own video. Ask the agent to transcribe a supplied TikTok link, identify repeated phrases, and suggest a clearer opening. Have it quote the original wording before offering edits so you can compare the recommendation with what was actually said.

Prepare searchable notes. Ask for a title, a brief outline, and a small set of tags grounded in the transcript. Include the job ID and source URL in your own notes system. This preserves the connection between the saved note and the video that produced it.

Draft subtitles. Ask the host to use the returned segment times and produce a subtitle draft. Review line breaks, reading speed, and timing in your editing software. Automatic speech timing is useful as a starting point, but the final publishing pass remains an editorial task.

Compare authorized clips. Supply specific video links and explain the comparison you want. Keep the queue within the account's concurrency limit and wait for each result. Ask the host to separate differences in spoken content from its own inference about the creators' intentions.

These prompts are examples of work your host can perform after transcription. They do not expand the API's access to private content or add video search, account crawling, or comment retrieval.

Test the protocol directly

A direct HTTP request can help distinguish a client configuration issue from an invalid key. Start with an initialize request using a real API key in your environment.

curl https://tiktoktranscriptapi.com/mcp \
  -H "Authorization: Bearer $TIKTOK_API_KEY" \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{
    "jsonrpc":"2.0",
    "id":1,
    "method":"initialize",
    "params":{
      "protocolVersion":"2025-06-18",
      "capabilities":{},
      "clientInfo":{"name":"my-client","version":"1.0.0"}
    }
  }'

The response includes the negotiated protocol version, server information, and tool capability. The client then sends an initialized notification and can discover tools. Notifications receive an empty HTTP 202 response.

curl https://tiktoktranscriptapi.com/mcp \
  -H "Authorization: Bearer $TIKTOK_API_KEY" \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -H 'MCP-Protocol-Version: 2025-06-18' \
  -d '{"jsonrpc":"2.0","method":"notifications/initialized"}'

curl https://tiktoktranscriptapi.com/mcp \
  -H "Authorization: Bearer $TIKTOK_API_KEY" \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -H 'MCP-Protocol-Version: 2025-06-18' \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'

To request a transcript, send tools/call with the tool name and arguments. This creates real processing work and reserves one credit, so use a video you are authorized to process.

curl https://tiktoktranscriptapi.com/mcp \
  -H "Authorization: Bearer $TIKTOK_API_KEY" \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -H 'MCP-Protocol-Version: 2025-06-18' \
  -d '{
    "jsonrpc":"2.0",
    "id":3,
    "method":"tools/call",
    "params":{
      "name":"create_transcript",
      "arguments":{
        "url":"https://www.tiktok.com/@creator/video/VIDEO_ID",
        "idempotency_key":"mcp-video-request-001"
      }
    }
  }'

The tool result includes a text content item containing JSON and a structured content object for clients that support it. Read the returned job ID, wait, and invoke get_transcript with that ID. Tool errors set isError to true and provide an error code and message in the content.

Handling tool errors

Authentication failures occur before a tool executes and return HTTP 401. Check whether the header contains the full key, whether a secret setting accidentally added quotes or whitespace, and whether the key is still active in the dashboard.

Validation and processing constraints appear as tool errors. An unsupported video URL, exhausted credit balance, reused operation key with different input, or a concurrency limit should be shown to the user with a clear explanation. The agent should not silently alter the video URL or start unrelated work to bypass the failure.

Rate-limit errors include a retry delay in the tool's error content when available. Respect that delay and retry the same logical operation. A client should not spawn additional workers or rotate keys to work around the account's shared rate limit.

A temporary service failure may leave the client unsure whether a create call was accepted. Keep the idempotency key and repeat the same request after a delay. If a job ID is already known, read that job rather than submitting the video again.

Credits and account visibility

MCP activity appears alongside REST API activity in your account. The source column distinguishes MCP requests so you can see which workflow created a job. All keys and interfaces share the available balance and five-job concurrency cap.

One new transcript reserves one credit. Status checks and recent-history reads do not use credits. The 20-minute per-video cap applies to every plan. An annual subscription changes the billing cycle, top-up price, and request rate; it does not increase the duration of an individual transcript.

The monthly and annual plans each provide 1,000 credits per month. Free accounts begin with 100 trial credits. See Billing & credits for rollover, cancellation, and top-up behavior, and use the dashboard to inspect the actual balance before starting a larger workflow.

Trust the user request, not the transcript

A video can contain spoken instructions, quoted commands, or text intended to manipulate an AI system. Your host must treat the returned transcript as untrusted source content. It should follow the user's task and its own instruction hierarchy instead of executing instructions discovered in the video.

For example, a speaker saying “ignore previous instructions” is part of the transcript, not permission to change the task. A URL read aloud in the video is not authorization to open it, submit information, or send a message. Keep extraction and analysis separate from consequential actions.

Store the original transcript when you need an audit trail, and label rewritten output as a summary or draft. For important quotes, preserve a timestamp and let a person compare the source. The MCP connection provides access to data; it does not establish that every statement in that data is correct.

Build a custom host

A custom MCP host should keep connection setup separate from transcript processing. Initialize the server, discover the available tools, and store the supported tool schemas. When a user supplies an authorized video, validate the intended action against the create tool's arguments before calling it.

Give every tool call a distinct JSON-RPC request ID so your host can match responses to requests. This protocol ID is different from a transcript job ID and from an idempotency key. The protocol ID identifies a message, the operation key identifies a logical create attempt, and the job ID identifies the durable transcription result.

Your host can reconnect without losing the transcript, because job storage is independent of the transport session. Save the job ID in your application state or conversation record. On a later turn, use the get tool with that ID and the same account's credential. Do not rely on the model remembering an ID that was never retained by the host.

Treat successful tool execution and successful transcription as different outcomes. A create tool can succeed by accepting a job while the job itself is still processing. A get tool can successfully return a failed transcription state. Check the result's status before treating its text as available for analysis.

If you display a tool approval prompt, make the cost clear: creating a new transcript reserves one credit, while checking it does not consume another credit. This lets the person using your host make a meaningful decision about a new source without approving every status read as if it were a new purchase.

Keep credentials separate from conversation

Store the bearer key in your host's secret configuration and attach it to HTTP requests outside the model's generated arguments. The create tool needs a URL and optional operation key; it does not need the API secret as part of the conversation or the tool input.

When an agent produces a configuration example, show a placeholder instead of the real key. If a person accidentally pastes a key into a shared conversation, revoke it and generate a replacement. Deleting the visible message alone cannot guarantee that every copy has disappeared from logs or downstream systems.

For a shared host, decide whether one account is appropriate for the entire team. The server's keys do not create separate per-key transcript permissions. If different groups must have different access, connect distinct accounts or enforce a separate application access layer before exposing results.

Troubleshooting a connection

If the client reports that the endpoint is unsupported, confirm that it is using Streamable HTTP. A client configured for the older SSE transport may try a GET stream and receive HTTP 405. Change the transport instead of appending guessed paths to the endpoint.

If tool discovery succeeds but transcription fails, inspect the actual tool error. A key can be valid while the account has no remaining credits. A video can have a plausible URL while still requiring a TikTok login. Test one known public, authorized video before adding a larger workflow.

If a result never appears, keep its job ID and inspect it in the dashboard. Avoid a polling loop that immediately calls the status tool again with no delay. The rate limit applies to reads, and fast polling does not accelerate processing.

For help, include your MCP client's name, the transport setting, the tool name, the approximate request time, and the job ID. Do not send your API key or a screenshot that exposes its complete value. Contact support for integration assistance.