> ## Documentation Index
> Fetch the complete documentation index at: https://docs.modulate.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# FAQ

> Frequently asked questions about authentication, models, audio formats, pricing, rate limits, streaming, errors, privacy, and support.

## Authentication and API keys

**How do I get an API key?** [Create a free account](https://platform.modulate.ai/signup-request) and your API key will be available in the dashboard after sign-up.

**How do I authenticate my requests?** Authentication works differently depending on the API type.

For REST endpoints, pass your key in the `X-API-Key` header:

```bash theme={null}
X-API-Key: your_api_key_here
```

For WebSocket endpoints, pass it as a query parameter at connection time:

```text theme={null}
wss://platform.modulate.ai/api/velma-2-stt-streaming?api_key=your_api_key_here
```

**Is it safe to put my API key in code?**

<Warning>
  Never commit credentials to source control. API keys pushed to a repository — even briefly — should be considered compromised. Rotate the key immediately if this happens.
</Warning>

Store your key in a `.env` file, load it at runtime via `python-dotenv` or your environment's secret manager, and ensure `.env` is in your `.gitignore`. The [Quick start](/quickstart) guide covers this setup in full.

## Models and capabilities

**What models are available?**

| Model | API type | Primary use |
| - | - | - |
| Multilingual Transcription Batch | REST | Transcription with the full feature set |
| Multilingual Transcription Streaming | WebSocket | Real-time transcription with per-utterance results |
| English Fast Transcription Batch | REST | High-throughput English transcription at lowest cost |
| English Fast Transcription Streaming | WebSocket | Low-latency English transcription with partials every \~1.5s |
| Multilingual Fast Transcription Batch | REST | Fast multilingual transcription with optional language declaration |
| Multilingual Fast Transcription Streaming | WebSocket | Low-latency multilingual transcription across 25 auto-identified languages |
| Deepfake Detection Batch | REST | Analyzing recorded audio files for synthetic speech |
| Deepfake Detection Streaming | WebSocket | Live deepfake detection with results from 500ms onward |
| Emotion Detection Batch | REST | Classify the emotional tone of an audio file |
| Accent Detection Batch | REST | Classify the speaker accent of an audio file |
| PII/PHI Redaction Batch | REST | Transcription with PII/PHI text redaction and audio silencing |
| PII/PHI Redaction Streaming | WebSocket | Real-time PII/PHI redaction — redacted transcript and MP3 clips per utterance |
| Music & Speech Detection Batch | REST | Classify audio as music, speech, or neither |
| Music & Speech Detection Streaming | WebSocket | Real-time audio classification as music, speech or neither |
| AI Music Detection Batch | REST | Detect AI-generated music in audio |
| AI Music Detection Streaming | WebSocket | Real-time detection of AI-generated music in audio |
| Audio Event Detection Batch | REST | Detect which of 42 non-speech sound events are present in an audio file |
| Language Detection | REST | Identify the spoken language of an audio file |

**What languages does transcription support?** The Multilingual Transcription batch and streaming models [support 100 languages](/get-started/language-detection#supported-languages) with automatic language detection. Language is detected per-utterance, so code-switching within a single file is handled automatically. Multilingual Fast Transcription (batch) also transcribes any supported language — declare it with the optional `language` parameter or let it be detected automatically. Multilingual Fast Transcription (streaming) covers 25 languages, always auto-identified, and does not report which one it detected. The English Fast Transcription model is English-only.

**What optional enrichments are available on transcription?** The Multilingual Transcription batch and streaming models support the following optional fields, configurable per request:

| Parameter | What it adds | Default |
| - | - | - |
| `speaker_diarization` | Distinct speaker labels per utterance | `true` |
| `emotion_signal` | Detected emotional tone (e.g. Neutral, Happy, Frustrated) | `false` |
| `accent_signal` | Detected accent (e.g. American, British, Indian) | `false` |
| `deepfake_signal` | Deepfake score per utterance (0.0 = human, 1.0 = synthetic) | `false` |
| `pii_phi_tagging` | PII/PHI wrapped with tags in transcript text | `false` |

English Fast Transcription (batch) supports two independent opt-in flags, both defaulting to `false`, and none of the other enrichments:

| Parameter | What it adds | Default |
| - | - | - |
| `time_stamps` | A `words` array giving each word a start time, end time, and alignment confidence | `false` |
| `speaker_diarization` | An `utterances` array of speaker-labeled turns with text and timing | `false` |

`words` times are in seconds, while `utterances` times are in milliseconds; both are measured from the start of the file. See [English Fast Transcription (batch)](/get-started/stt#english-fast-transcription-batch) for the full response shape.

English Fast Transcription (streaming) has one optional enrichment of its own:

| Parameter | What it adds | Default |
| - | - | - |
| `diarize` | `speaker`, `n_speakers`, `speakers_capped`, and `speaker_purity` on each final `utterance` | `false` |

The `speaker` index is stable only within one connection, so it cannot be matched across calls. See [English Fast Transcription (streaming)](/get-started/stt#speaker-labels).

**What's the difference between PII/PHI tagging and PII/PHI redaction?**

These are two separate capabilities with different outputs:

* **PII/PHI tagging** (`pii_phi_tagging=true` on Multilingual Transcription batch or streaming) — identifies PII/PHI spans in the transcript and wraps them with tags. The original text content is preserved. Use this when downstream systems need to detect or handle sensitive spans while retaining the full transcript.
* **PII/PHI redaction** (PII/PHI Redaction APIs) — replaces each detected PII/PHI span with an empty marker tag (e.g. `<pii:name></pii:name>`, `<pii:ssn></pii:ssn>`, `<phi></phi>`) in the transcript **and** silences the corresponding audio ranges in the returned MP3. Use this when the audio itself must be clean — for example, recordings that will be shared, archived, or reviewed by parties who should not hear sensitive information.

**What types of PII/PHI get redacted?** Currently, every entity type the model can detect is redacted, covering both personal information (PII) and health information (PHI). For more detail, see the PII/PHI Redaction Batch reference in the **API Reference** tab.

**Can I configure which PII/PHI tags are enabled?** Not at this time, but it's on our roadmap. [Reach out to Support](/support) to let us know what your specific needs are.

**How accurate is the deepfake detection?** The Deepfake Detection model scores 1.104% average EER across the 14 datasets of the Hugging Face Speech DF Arena benchmark, ranked 1st as of 11 March 2026. Quoted as accuracy that is the same figure restated: 98.9%. [Deepfake Detection results](/benchmarks/deepfake-detection) carries the competitor comparison, both EER metrics, and the live source link.

**What does the deepfake `confidence` score mean?** Confidence represents how certain the model is in its verdict, on a scale of 0 to 1. A frame with `verdict: "synthetic"` and `confidence: 0.97` means the model is highly confident that segment contains AI-generated speech. A `no-content` verdict indicates the frame is silent or contains no usable audio — these frames are not sent through the model and always return `confidence: 1.0`.

## Audio formats and file requirements

**What audio formats are supported?** The accepted set differs per endpoint, and each capability page lists its own in full. Deepfake Detection, Music & Speech Detection, AI Music Detection, Language Detection, and English Fast Transcription accept 96 file extensions in batch. All of those except Language Detection, which is batch-only, accept 79 container formats plus 22 raw formats in streaming. The remaining batch endpoints accept AAC, AIFF, FLAC, MOV, MP3, MP4, OGG, Opus, WAV, and WebM, and the remaining streaming endpoints accept 7 container formats plus 20 raw formats.

Streaming endpoints split into two groups. Transcription, Redaction, and Velma Triage auto-detect self-describing containers, so `audio_format` is optional. Deepfake Detection, Music & Speech Detection, AI Music Detection, and English Fast Transcription require `audio_format` on every connection, including containers, and omitting it closes the connection with `1003`.

Raw PCM, mu-law, and A-law formats are headerless everywhere they are accepted, so they always require `sample_rate` and `num_channels` alongside `audio_format`.

**Is there a file size limit?** 100 MB for all batch endpoints.

**Is there a minimum audio length?** For deepfake detection, audio must be at least 0.5 seconds. Files shorter than this are rejected with a `422`. For transcription, very short clips may return empty or minimal results.

**What is the recommended audio length for deepfake detection?** 4–60 seconds is the recommended range. Files shorter than one full 4-second analysis window are padded before inference. Leading and trailing silence is trimmed automatically — frame timestamps reflect positions in the original file.

## Pricing and billing

**How is usage billed?** Billing is credit-based and priced per hour of audio processed. Prices range from \$0.01/hour to \$1.25/hour depending on the model. Review pricing for all models here: [platform.modulate.ai/pricing](https://platform.modulate.ai/pricing)

**Is there a free tier?** Yes. Free credits are included when you create an account — no credit card required to get started.

**Where can I monitor my usage?** Real-time usage and billing details are in the [Usage dashboard](https://platform.modulate.ai/dashboard/usage).

## Rate limits

**What rate limits apply?** Concurrency is capped per model: the number of simultaneous in-flight requests or active WebSocket connections against one endpoint. The default is 3. Credits are tracked separately and are not a rate limit.

**What happens when I hit the concurrency cap?** REST endpoints return `429`. WebSocket connections close with code `4030`. The [Usage dashboard](https://platform.modulate.ai/dashboard/usage) shows current usage.

<Tip>
  **Production recommendation:** bound parallel requests with a semaphore sized to the cap. Retrying into a full queue does not help. Caps are per model, so spreading load across models raises total throughput.
</Tip>

**Can the cap be increased?** Contact [support@modulate.ai](mailto:support@modulate.ai) with the model and expected traffic.

## Streaming (WebSocket)

**How do I signal the end of my audio stream?** Send an empty text frame (`""`) on the open connection. The server will drain any buffered audio, deliver outstanding results, send a `done` message, then close the connection cleanly.

**What does the `done` message look like?**

<Accordion title="Multilingual Transcription streaming done">
  ```json theme={null}
  {
    "type": "done",
    "duration_ms": 45000
  }
  ```
</Accordion>

<Accordion title="Deepfake streaming done">
  ```json theme={null}
  {
    "type": "done",
    "duration_ms": 12500,
    "frame_count": 10
  }
  ```
</Accordion>

**What are partial results in Multilingual Transcription streaming?** When `partial_results=true`, the server emits `partial_utterance` messages while speech is in progress, before the utterance is finalized. Each partial replaces the previous one — the final `utterance` message supersedes all preceding partials for that segment. When the emotion, accent, or deepfake signals are enabled, each partial also carries the latest interim `emotion`, `accent`, and `deepfake_score` values (`null` until a value is available). Useful for live caption rendering where low perceived latency matters.

**What WebSocket close codes should I handle?**

<Accordion title="WebSocket close code reference">
  | Code | Meaning |
  | - | - |
  | `1000` | Normal closure — received after `done`, connection finished cleanly |
  | `1003` | Invalid query parameters (bad `audio_format`, `sample_rate`, or `num_channels`), or a protocol/configuration error |
  | `1011` | Internal server error, or processing ended before completion |
  | `4001` | Invalid API key |
  | `4002` | Audio could not be decoded or doesn't match the declared format |
  | `4003` | The request is not permitted |
  | `4004` | The API key does not have access to this model |
  | `4029` | Insufficient credits |
  | `4030` | Concurrent request limit reached |
  | `4031` | Monthly usage limit reached |
</Accordion>

## Errors

**What does a `503` response mean?** The inference server is temporarily overloaded. Wait a moment and retry. For production workloads, implement exponential backoff with jitter rather than an immediate retry loop.

**What does a `504` response mean?** The request timed out — batch processing has a 60-second limit. This is uncommon for typical audio lengths. If you see it consistently on files within the recommended size range, contact [support@modulate.ai](mailto:support@modulate.ai).

**My file was rejected with `422`. Why?** The audio is too short for analysis. Deepfake detection requires a minimum of 0.5 seconds. Check the actual duration of your file — empty or near-silent files sometimes report a longer duration than their usable content.

## Privacy and data

**Does Modulate store the audio or outputs?** By default, no data is stored when using our APIs.

**Does Modulate sell the audio I send through the API?** No. Modulate does not sell personal data, including audio submitted through the API. Audio processed via the platform is used solely to deliver the service and, in specific cases, to improve Modulate's models — see the retention and training questions below for details.

**How long is my audio retained after I send it?** Any audio submitted through the platform API *and* is marked for storage by the user is retained for **35 days** from the date of upload, after which it is permanently deleted. **By default, no audio is stored at all.** Enterprise customers with annual commitment agreements can negotiate custom retention periods through their account representative. Self-service customers cannot configure retention periods.

If you need to delete specific audio before the 35-day period expires, you can do so through the platform interface or API.

**Is my audio used to train Modulate's AI models?** It depends on your account type:

* **Self-service (pay-as-you-go) customers** — audio that *is marked for storage* by the user may be used by Modulate to train and improve its models.
* **Enterprise customers (annual commitment)** — participation in model training is optional. To opt out, contact [legal@modulate.ai](mailto:legal@modulate.ai). Opting out does not affect the quality or functionality of your API results.

When audio is used for training, Modulate extracts acoustic and linguistic patterns to improve model performance. Customer audio is never sold or used for purposes unrelated to platform improvement.

**What data does Modulate collect about my API usage?** Modulate collects account identifiers, API usage logs, session data, and any metadata you provide. Usage metadata — such as timestamps, API call counts, and conversation counts — is retained separately from audio for operational and billing purposes.

**Who is responsible for privacy compliance when I use the API to process my users' audio?** When you use the Modulate platform to analyze audio from your own end users, you are the data controller and Modulate acts as a data processor on your behalf. This means you are responsible for:

* Providing required privacy notices to your end users before collecting audio
* Obtaining any necessary consents for recording and analysis
* Establishing a lawful basis for processing under applicable data protection laws
* Complying with audio recording laws in your jurisdiction (wiretapping statutes, consent-to-record requirements, biometric data regulations)
* Responding to your end users' data rights requests (access, deletion, correction)

If your end users submit data rights requests related to audio you processed through the API, those requests should come to you as the data controller. You can then request Modulate's assistance, and Modulate will cooperate with verified requests.

**Does Modulate offer a Data Processing Agreement (DPA)?** Yes. If you are subject to GDPR, UK GDPR, or other regulations requiring a DPA, Modulate offers a standard agreement that includes appropriate data protection terms, security commitments, and Standard Contractual Clauses for international transfers. Contact [legal@modulate.ai](mailto:legal@modulate.ai) to request a DPA.

**Where is my data processed and stored?** Audio and account data are primarily processed and stored in the United States. For customers transferring data from the EU, UK, or other jurisdictions with cross-border transfer requirements, Modulate implements appropriate safeguards including Standard Contractual Clauses.

**How do I exercise my privacy rights or submit a data request?** Contact [privacy@modulate.ai](mailto:privacy@modulate.ai) for access, correction, or deletion requests. Modulate aims to respond within 30 days. Because audio is processed on behalf of platform customers, Modulate may direct end-user requests to the relevant customer (data controller) in some cases.

To opt out of marketing communications, click the unsubscribe link in any Modulate email or contact [privacy@modulate.ai](mailto:privacy@modulate.ai) directly.

<Note>
  This section covers the details most relevant to API users. For complete information — including cookie practices, third-party data sharing, and regional rights — see Modulate's [full Privacy Policy](https://www.modulate.ai/privacy-policy) and the [Velma Services Privacy Addendum](https://www.modulate.ai/privacy-policy#velma-services-privacy-addendum).
</Note>

## Support

**How do I get help?** Check out our [Support](/support) page.

**Where can I learn more about Modulate?** Visit [modulate.ai](https://modulate.ai) to learn about Modulate's mission, or try [Velma Preview](https://preview.modulate.ai) to explore voice analysis in the browser without writing any code.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.