Skip to content

Connect Descript to Claude: Automate Imports and Media Workflows

Learn how to connect Descript to Claude using a managed MCP server to automate video imports, AI editing, transcription, and publishing workflows.

Sidharth Verma Sidharth Verma · · 9 min read
Connect Descript to Claude: Automate Imports and Media Workflows

If your team needs to connect Descript to Claude to automate media imports, generate AI edits, extract transcripts, or execute publishing pipelines, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's function-calling capabilities and Descript's REST API. You can either build, host, and maintain this stateful infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on /connect-descript-to-chatgpt-edit-transcribe-and-publish-projects/ or explore our broader architectural overview on /connect-descript-to-ai-agents-manage-edit-and-publish-media-assets/.

Giving a Large Language Model (LLM) read and write access to a sprawling, media-heavy application like Descript is an engineering challenge. You have to handle OAuth 2.0 token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Descript's heavy reliance on asynchronous job polling. Every time Descript updates an endpoint or deprecates an agent model, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Descript, connect it natively to Claude Desktop, and execute complex media processing workflows using natural language.

The Engineering Reality of the Descript API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against Descript's APIs is painful. You are not just integrating a simple CRUD database - you are orchestrating cloud-based video rendering, heavy file transfers, and AI-driven compositing.

If you decide to build a custom MCP server for Descript, here are the specific challenges you will face:

Asynchronous Heavy-Lifting Descript is fundamentally an asynchronous platform. Operations like importing media, applying AI edits via the Descript agent, or publishing a final composition do not return immediate results. Instead, the API returns a job_id. Your MCP server must expose polling mechanisms that allow the LLM to repeatedly check the status of a job (e.g., success, error, partial) without locking up the context window or timing out the HTTP connection.

Complex Project vs. Drive Hierarchies Descript enforces a strict hierarchy: Drives contain Projects, and Projects contain Compositions and Media Files. However, you can also have Drive-level media. An LLM has no inherent context on this domain model. If it tries to import a file, it needs to know whether to target the workspace-level media library or a specific project. You must build an abstraction layer that presents a unified set of operations to Claude, explicitly defining when a drive_id is required versus a project_id.

Binary vs. Structured Exports Exporting transcripts from Descript involves handling varying response types based on the requested format. A request for a .txt or .markdown transcript returns a standard text payload, while a request for .docx returns a binary stream. If your MCP server does not properly negotiate content types and decode binary payloads into something Claude can understand (or write them to a local filesystem intermediary), the integration will fail silently with corrupted text.

Step 1: Generating the Descript MCP Server URL

Truto's MCP servers turn any connected Descript integration into an MCP-compatible tool server. Tool generation is dynamic and documentation-driven. Rather than hand-coding tool definitions, Truto derives them from Descript's resource definitions and schemas. If an endpoint is documented, it becomes an AI tool.

Each MCP server is scoped to a single integrated account (a connected instance of Descript for a specific tenant). The server URL contains a cryptographic token that encodes which account to use and what tools to expose.

Method A: Via the Truto UI

If you prefer a visual interface, you can generate the MCP server URL directly from the Truto dashboard:

  1. Navigate to the integrated account page for the specific Descript connection.
  2. Click the MCP Servers tab.
  3. Click Create MCP Server.
  4. Select the desired configuration (e.g., human-readable name, allowed methods, tag filters).
  5. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/<hashed-token>).

Method B: Via the Truto API

For programmatically provisioning servers - such as spinning up temporary MCP access for an automated agent - use the Truto REST API.

Make a POST request to /integrated-account/:id/mcp:

curl -X POST https://api.truto.one/integrated-account/<descript_account_id>/mcp \
  -H "Authorization: Bearer <YOUR_TRUTO_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Descript Media Automator",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'

The API validates the Descript integration, generates a secure token, hashes it via HMAC for storage in Cloudflare KV, and returns the endpoint:

{
  "id": "mcp_srv_123456",
  "name": "Descript Media Automator",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

This URL is fully self-contained. It handles the JSON-RPC 2.0 protocol translation, argument parsing, and underlying Descript OAuth refreshes.

Step 2: Connecting the MCP Server to Claude

Once you have the Truto MCP URL, connecting it to Claude is a matter of configuration. The client requires no additional logic, as the Truto endpoint fully implements the MCP specification.

Method A: Via the Claude UI

For users operating inside Claude's web or desktop interfaces:

  1. Open Claude and navigate to Settings -> Integrations -> Add MCP Server.
  2. Name the integration (e.g., "Descript Workspace").
  3. Paste the Truto MCP URL generated in Step 1.
  4. Click Add.

Claude will immediately ping the endpoint, execute an initialize handshake, and call tools/list to discover the available Descript operations.

Method B: Via Manual Config File

If you are using Claude Desktop in a developer environment, you can edit the claude_desktop_config.json file to route traffic through the official MCP SSE (Server-Sent Events) transport wrapper.

Open your configuration file and add the server:

{
  "mcpServers": {
    "descript-truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/<YOUR_TOKEN_HERE>"
      ]
    }
  }
}

Restart Claude Desktop. The model now has direct access to read, write, and orchestrate your Descript media.

Descript Hero Tools for Claude

When Claude calls a tool, all arguments arrive as a single flat object. Truto's MCP router splits them into query and body parameters dynamically using the underlying Descript integration schemas. Here are the highest-leverage tools available for Descript.

create_a_descript_jobs_agent

This tool instructs the Descript background AI agent to create or edit a project based on a natural language prompt. You must provide either a project_id to edit an existing workspace, or a project_name to scaffold a new one.

"Use the Descript agent to edit the project 'Interview Rough Cut'. Remove all filler words, tighten the gaps between sentences, and balance the audio levels across the whole composition."

create_a_descript_import_project_media

Uploads media files into a specific Descript project and optionally creates compositions from them. Because media processing takes time, this tool returns a job_id rather than a finished asset.

"Import the video file from this URL into the 'Q3 All Hands' project and automatically create a new composition from the media."

create_a_descript_jobs_publish

Triggers the rendering and publishing pipeline for a project composition. This creates a shareable web link and a downloadable exported media file. This is an asynchronous job.

"Publish the composition for the 'Marketing Promo V2' project. I need the final shareable URL so I can send it to the client."

create_a_descript_export_transcript

Exports the text transcript from a Descript project composition. It supports multiple formats (txt, markdown, html, rtf, docx, srt) and allows you to toggle speaker labels, markers, and timecodes.

"Export the transcript for the recent 'Tech Talk' episode in Markdown format. Make sure to include speaker labels and timestamps."

get_single_descript_job_by_id

Because Descript relies heavily on background processing, Claude must use this tool to check the status of import, publish, or agent jobs. The result field varies based on the job type, but the job_state will tell the model if it needs to keep waiting.

"Check the status of job ID 'job_883x91'. If it is complete, extract the download_url from the result payload."

list_all_descript_projects

Lists Descript projects accessible within the authenticated user's drive. This is typically the first tool Claude calls to discover the id of a specific project before attempting an edit or export.

"Search my Descript drive for any projects created in the last 7 days containing the word 'Webinar', and return their project IDs."

For the complete tool inventory and granular JSON schema details, refer to the Descript integration page.

Workflows in Action

Giving Claude access to individual endpoints is useful, but the real power of MCP emerges when the model chains tools together to execute multi-step workflows.

Scenario 1: Automated Podcast Transcription & Export

The Prompt:

"Find the Descript project named 'Engineering Podcast Ep 4', export the transcript in Markdown format with speaker labels, and summarize the key talking points for the show notes."

How Claude Executes It:

  1. Find the project: Claude calls list_all_descript_projects passing the name filter as "Engineering Podcast Ep 4". It extracts the id from the response.
  2. Request export: Claude calls create_a_descript_export_transcript passing the project_id, format: "markdown", and setting speaker labels to true.
  3. Process content: Claude reads the returned text payload, parses the Markdown, and uses its core LLM capabilities to write the show notes summary for the user.

Scenario 2: AI-Driven Video Assembly and Publishing

The Prompt:

"Import this raw Zoom recording URL into a new project called 'Customer Testimonial'. Tell the Descript agent to cut out the filler words and silence gaps. Once the edit is done, publish the video and give me the shareable link."

How Claude Executes It:

  1. Import media: Claude calls create_a_descript_import_project_media with the provided URL and the new project name. It receives a job_id.
  2. Poll import status: Claude calls get_single_descript_job_by_id periodically until the media is fully imported and the project_id is available.
  3. Execute AI edit: Claude calls create_a_descript_jobs_agent passing the new project_id and the prompt: "Cut out filler words and silence gaps." It receives a second job_id.
  4. Poll edit status: Claude calls get_single_descript_job_by_id to wait for the editing job to finish.
  5. Publish composition: Claude calls create_a_descript_jobs_publish passing the project_id. It receives a third job_id.
  6. Fetch final link: Claude polls the publish job until it hits a success state, extracts the share_url, and presents it to the user.
sequenceDiagram
    participant User as User
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant Descript as Descript API

    User->>Claude: "Import this URL into a new project, remove filler words, and publish."
    
    Claude->>MCP: Call create_a_descript_import_project_media
    MCP->>Descript: POST /v1/imports
    Descript-->>MCP: Return import_job_id
    MCP-->>Claude: Return import_job_id
    
    loop Poll Import
        Claude->>MCP: Call get_single_descript_job_by_id(import_job_id)
        MCP->>Descript: GET /v1/jobs/{import_job_id}
        Descript-->>MCP: Return success & project_id
        MCP-->>Claude: Return project_id
    end

    Claude->>MCP: Call create_a_descript_jobs_agent(project_id, "remove filler")
    MCP->>Descript: POST /v1/jobs/agent
    Descript-->>MCP: Return agent_job_id
    MCP-->>Claude: Return agent_job_id

    loop Poll Agent Edit
        Claude->>MCP: Call get_single_descript_job_by_id(agent_job_id)
        MCP->>Descript: GET /v1/jobs/{agent_job_id}
        Descript-->>MCP: Return success
        MCP-->>Claude: Return success
    end

    Claude->>MCP: Call create_a_descript_jobs_publish(project_id)
    MCP->>Descript: POST /v1/jobs/publish
    Descript-->>MCP: Return publish_job_id
    MCP-->>Claude: Return publish_job_id

    loop Poll Publish
        Claude->>MCP: Call get_single_descript_job_by_id(publish_job_id)
        MCP->>Descript: GET /v1/jobs/{publish_job_id}
        Descript-->>MCP: Return success & share_url
        MCP-->>Claude: Return share_url
    end

    Claude-->>User: "Done! Here is your published video link."

Security and Access Control

Exposing your core media infrastructure to an autonomous model requires strict boundary controls. Truto enforces security at the MCP token level, ensuring Claude only acts within the parameters you define.

  • Method Filtering: By defining config.methods during token creation, you can restrict the MCP server to specific operations. Setting this to ["read"] ensures Claude can list projects and export transcripts, but structurally prevents it from calling create_a_descript_jobs_publish or deleting jobs.
  • Tag Filtering: Descript resources are tagged by domain. You can pass config.tags (e.g., ["media", "jobs"]) to limit the LLM's surface area strictly to those functional domains, excluding administration or billing endpoints entirely.
  • Enforced API Token Authentication: For highly secure environments where the MCP URL might be visible in internal configurations, setting require_api_token_auth: true forces the client to pass a valid Truto API token in the Authorization header, adding a strict second layer of identity verification.
  • TTL and Auto-Expiration: Passing an expires_at ISO datetime schedules an automated cleanup alarm. Once expired, the token is purged from distributed KV storage and database records, ensuring temporary agents lose access exactly when intended.
  • Rate Limit Normalization: Descript strictly enforces API rate limits, especially for heavy media operations. Truto does not silently retry, throttle, or apply backoff on rate limit errors. If Descript returns an HTTP 429, Truto passes that error directly to the caller, normalizing the upstream rate limit data into standard IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller (Claude or your agent framework) is responsible for reading these headers and executing its own retry and backoff logic.

Strategizing Your Descript AI Integration

Building an MCP server for Descript forces you to reckon with heavy asynchronous polling, nested object hierarchies, and media payload translation. If you build it in-house, your engineering team owns the burden of maintaining OAuth flows and translating API documentation into LLM-readable schemas indefinitely.

Using a managed architecture like Truto abstracts the infrastructure away. You connect the Descript account once, dynamically generate a secure MCP URL scoped precisely to the tasks you want automated, and hand it to Claude. The model gets immediate, reliable access to edit, transcribe, and publish media - and your engineers get to focus on core product logic instead of integration maintenance.

FAQ

How do I handle Descript's asynchronous jobs with Claude?
Descript relies heavily on background processing for imports, agent edits, and publishing. Truto exposes endpoints like get_single_descript_job_by_id, allowing Claude to poll the job status until it returns a success or error state.
Can I restrict Claude to only read transcripts from Descript?
Yes. When generating the Truto MCP server URL, you can configure method filtering to only allow "read" operations. This prevents the LLM from creating new projects or publishing media.
How does Truto handle Descript API rate limits?
Truto does not absorb, retry, or throttle rate limit errors. It passes HTTP 429 errors directly back to the client, normalizing the data into standard IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) so the caller can implement its own backoff logic.
What is the fastest way to connect the MCP server to Claude Desktop?
You can add the generated Truto MCP URL directly into the claude_desktop_config.json file using the @modelcontextprotocol/server-sse transport command, or use the Settings > Integrations UI if available in your Claude client.

More from our Blog