---
title: "Connect Descript to Claude: Automate Imports and Media Workflows"
slug: connect-descript-to-claude-automate-imports-and-media-workflows
date: 2026-11-19
author: Sidharth Verma
categories: ["AI & Agents"]
excerpt: "Learn how to connect Descript to Claude using a managed MCP server to automate video imports, AI editing, transcription, and publishing workflows."
tldr: "Connect Descript to Claude via Truto's managed MCP server. This guide covers bypassing Descript's complex async API quirks, configuring secure token access, and executing multi-step media workflows with AI."
canonical: https://truto.one/blog/connect-descript-to-claude-automate-imports-and-media-workflows/
---

# 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](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). 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](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), 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/](https://truto.one/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/](https://truto.one/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.

> Want to give your AI agents secure, authenticated access to Descript and 100+ other SaaS APIs? Let's talk about managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Descript API

A custom MCP server is a self-hosted integration layer. While the open [MCP standard](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) 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](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), 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`:

```bash
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:

```json
{
  "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:

```json
{
  "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](https://truto.one/integrations/detail/descript).

## 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.

```mermaid
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.
