Skip to main content
Glama

Transcribe Audio URL

transcribe_audio_url

Submit a public audio or video URL for transcription with speaker diarization, returning a job ID to track progress.

Instructions

Submit a publicly-accessible audio or video URL for transcription with speaker diarization. Returns a job_id you can poll with get_transcription_status, or use transcribe_audio_url_sync to wait synchronously.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
urlYesPublic URL of audio/video file (mp3, m4a, wav, mp4, webm, etc.) Max 200 MB.
languageNoISO 639-1 code, e.g. "en", "es". Auto-detected if omitted.

Implementation Reference

  • The handler function that executes the transcribe_audio_url tool logic. Calls client.submitTranscription(url, language) and returns the job_id.
    async ({ url, language }) => {
      const r = await client.submitTranscription(url, language);
      return {
        content: [{ type: 'text', text: `Job submitted. job_id: ${r.id}` }],
        structuredContent: jsonStructured(r),
      };
    },
  • Input schema for transcribe_audio_url: requires a public audio/video URL (max 200 MB) and optional 2-letter ISO language code.
    {
      title: 'Transcribe Audio URL',
      description:
        'Submit a publicly-accessible audio or video URL for transcription with speaker diarization. Returns a job_id you can poll with get_transcription_status, or use transcribe_audio_url_sync to wait synchronously.',
      inputSchema: z.object({
        url: z
          .string()
          .url()
          .describe(
            'Public URL of audio/video file (mp3, m4a, wav, mp4, webm, etc.) Max 200 MB.',
          ),
        language: z
          .string()
          .length(2)
          .optional()
          .describe(
            'ISO 639-1 code, e.g. "en", "es". Auto-detected if omitted.',
          ),
      }),
      annotations: { readOnlyHint: false, openWorldHint: true },
  • Registration function that calls server.registerTool with name 'transcribe_audio_url', schema, annotations, and handler.
    export function register(server: McpServer, client: GhostMinutesClient): void {
      server.registerTool(
        'transcribe_audio_url',
        {
          title: 'Transcribe Audio URL',
          description:
            'Submit a publicly-accessible audio or video URL for transcription with speaker diarization. Returns a job_id you can poll with get_transcription_status, or use transcribe_audio_url_sync to wait synchronously.',
          inputSchema: z.object({
            url: z
              .string()
              .url()
              .describe(
                'Public URL of audio/video file (mp3, m4a, wav, mp4, webm, etc.) Max 200 MB.',
              ),
            language: z
              .string()
              .length(2)
              .optional()
              .describe(
                'ISO 639-1 code, e.g. "en", "es". Auto-detected if omitted.',
              ),
          }),
          annotations: { readOnlyHint: false, openWorldHint: true },
        },
        async ({ url, language }) => {
          const r = await client.submitTranscription(url, language);
          return {
            content: [{ type: 'text', text: `Job submitted. job_id: ${r.id}` }],
            structuredContent: jsonStructured(r),
          };
        },
      );
    }
  • src/server.ts:32-42 (registration)
    Top-level registration: calls registerTranscribeUrl(server, client) to wire up the tool on the server.
      registerTranscribeUrl(server, client);
      registerTranscribeSync(server, client);
      registerGetStatus(server, client);
      registerListTranscripts(server, client);
      registerGetTranscript(server, client);
      registerDeleteTranscript(server, client);
      registerSummarize(server, client);
      registerGetCredits(server, client);
    
      return server;
    }
  • The GhostMinutesClient.submitTranscription method which POSTs to /mcp/transcribe with audio_file_url and optional language.
    async submitTranscription(
      audioUrl: string,
      language?: string,
    ): Promise<{ id: string; [key: string]: unknown }> {
      try {
        const res = await this.http.post<
          unknown,
          AxiosResponse<{ id: string; [key: string]: unknown }>
        >(
          '/mcp/transcribe',
          {
            audio_file_url: audioUrl,
            ...(language ? { language } : {}),
          },
          {
            headers: this.hasApiKey()
              ? { Authorization: `Bearer ${this.apiKey}` }
              : {},
          },
        );
        return this.ensureOk(res);
      } catch (e) {
        this.handleThrown(e);
      }
    }
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations indicate readOnlyHint=false (write operation) and openWorldHint=true (unknown side effects). The description adds that transcription creates a job and returns a job_id, but does not elaborate on potential side effects or permissions needed. With moderate annotation coverage, the description adds minimal behavioral context beyond the async nature.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that efficiently communicates the core action, return value, and a key alternative. Every part serves a purpose with no waste.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple tool with 2 parameters (one required) and no output schema, the description covers the purpose, async behavior, and how to handle the result. It lacks details on error scenarios or limits, but is otherwise complete enough for an agent to use correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so baseline is 3. The description does not add meaningful information beyond what the schema already provides for the parameters. It mentions 'publicly-accessible' and 'speaker diarization' but these are not parameter-specific.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Submit a publicly-accessible audio or video URL') and the purpose ('transcription with speaker diarization'). It also distinguishes the asynchronous nature from the synchronous sibling tool transcribe_audio_url_sync and mentions the resulting job_id for polling with get_transcription_status.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit guidance on when to use this tool (async submission) versus alternatives: poll with get_transcription_status or use transcribe_audio_url_sync for synchronous waiting. It does not explicitly state when not to use it, but the context is clear enough.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Rocketech-Software-Development/ghostminutes-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server