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

# Create pronunciation dictionary

> Creates a new pronunciation dictionary with pronunciation rules for specific words.
Supports alias rules (word substitutions) and phoneme rules (phonetic pronunciations).
Provider-specific rule restrictions may apply.

## Rule Types

Pronunciation dictionaries support two types of rules:

**Alias Rules** (word substitutions):

* Replace one word with another
* Example: "CEO" → "Chief Executive Officer"

**Phoneme Rules** (phonetic pronunciations):

* Specify exact pronunciation using IPA (International Phonetic Alphabet)
* Example: "Kubernetes" → "kjˈuːbənˌiːts"

<Note>Some providers only support alias rules. Check provider-specific documentation for rule type restrictions.</Note>


## OpenAPI

````yaml https://blackbox.dasha.ai/swagger/v1/swagger.json post /api/v1/pronunciation-dictionaries
openapi: 3.0.4
info:
  title: Dasha BlackBox Agent API
  description: API for managing AI agents and calls
  contact:
    name: DashaAI Team
    email: support@dasha.ai
  version: v1
servers:
  - url: https://blackbox.dasha.ai
    description: Dasha BlackBox Agent API
security:
  - ApiKey: []
  - OAuth: []
tags:
  - name: ActivityLogs
  - name: Agents
  - name: AgentTestCases
  - name: CallResults
  - name: Calls
  - name: Chats
  - name: Copilot
  - name: CustomerData
  - name: Mcp
  - name: Media
  - name: Misc
  - name: PronunciationDictionaries
  - name: Providers
  - name: SipAliases
  - name: SipCredentials
  - name: SipPhoneNumbers
  - name: TextChat
  - name: TwilioProvider
  - name: Voice
  - name: WebhookTest
  - name: WebIntegrations
  - name: WebSocket
    description: WebSocket endpoints for real-time communication
paths:
  /api/v1/pronunciation-dictionaries:
    post:
      tags:
        - PronunciationDictionaries
      summary: Create pronunciation dictionary
      description: >-
        Creates a new pronunciation dictionary with pronunciation rules for
        specific words.

        Supports alias rules (word substitutions) and phoneme rules (phonetic
        pronunciations).

        Provider-specific rule restrictions may apply.
      requestBody:
        description: Dictionary configuration
        content:
          application/json:
            schema:
              allOf:
                - $ref: '#/components/schemas/CreatePronunciationDictionaryRequestDto'
              description: >-
                Configuration for creating a new pronunciation dictionary that
                controls how specific words and phrases are pronounced during
                text-to-speech synthesis. Pronunciation dictionaries allow you
                to customize voice output for technical terms, brand names,
                acronyms, or any text that needs specific pronunciation.
          text/json:
            schema:
              allOf:
                - $ref: '#/components/schemas/CreatePronunciationDictionaryRequestDto'
              description: >-
                Configuration for creating a new pronunciation dictionary that
                controls how specific words and phrases are pronounced during
                text-to-speech synthesis. Pronunciation dictionaries allow you
                to customize voice output for technical terms, brand names,
                acronyms, or any text that needs specific pronunciation.
          application/*+json:
            schema:
              allOf:
                - $ref: '#/components/schemas/CreatePronunciationDictionaryRequestDto'
              description: >-
                Configuration for creating a new pronunciation dictionary that
                controls how specific words and phrases are pronounced during
                text-to-speech synthesis. Pronunciation dictionaries allow you
                to customize voice output for technical terms, brand names,
                acronyms, or any text that needs specific pronunciation.
      responses:
        '201':
          description: Pronunciation dictionary created successfully
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PronunciationDictionaryResponseDto'
        '400':
          description: Invalid configuration or validation errors
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
        '401':
          description: Authentication failed or API key is missing
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
        '502':
          description: Gateway error occurred
        '503':
          description: Service temporarily unavailable
        '504':
          description: Request timeout occurred
components:
  schemas:
    CreatePronunciationDictionaryRequestDto:
      required:
        - name
        - provider
        - rules
      type: object
      properties:
        provider:
          minLength: 1
          type: string
          description: >-
            TTS provider for this pronunciation dictionary. Supported providers:
            ElevenLabs, Cartesia. The dictionary can only be used with voices
            from the same provider.
        name:
          maxLength: 64
          minLength: 1
          type: string
          description: >-
            Display name for the pronunciation dictionary. Used to identify and
            organize dictionaries in your account.
        rules:
          type: array
          items:
            oneOf:
              - $ref: '#/components/schemas/AliasPronunciationRule'
              - $ref: '#/components/schemas/PhonemePronunciationRule'
            description: >-
              Base class for pronunciation rules that control how specific text
              is spoken during TTS synthesis. Rules use polymorphic
              serialization with a type discriminator to support different
              pronunciation methods (alias or phonetic).
          description: >-
            Pronunciation rules that define how specific text should be spoken.
            Each rule specifies a word or phrase to match and how it should be
            pronounced, either using an alias (alternative text) or phonetic
            representation.
      additionalProperties: false
      description: >-
        Configuration for creating a new pronunciation dictionary that controls
        how specific words and phrases are pronounced during text-to-speech
        synthesis. Pronunciation dictionaries allow you to customize voice
        output for technical terms, brand names, acronyms, or any text that
        needs specific pronunciation.
    PronunciationDictionaryResponseDto:
      required:
        - content
        - contentHash
        - createdTime
        - lastUpdatedTime
        - name
        - orgId
        - provider
        - providerId
      type: object
      properties:
        providerId:
          minLength: 1
          type: string
          description: >-
            Unique identifier assigned by the TTS provider. Used to reference
            this dictionary when configuring voices or making API calls to the
            provider.
        provider:
          minLength: 1
          type: string
          description: >-
            TTS provider that hosts this pronunciation dictionary. Supported
            providers: ElevenLabs, Cartesia. The dictionary can only be used
            with voices from the same provider.
        orgId:
          minLength: 1
          type: string
          description: >-
            Organization that owns this pronunciation dictionary. Used for
            access control and resource management.
        contentHash:
          minLength: 1
          type: string
          description: >-
            Content hash for tracking dictionary changes. This hash changes
            whenever rules are added, removed, or modified, allowing you to
            detect updates without comparing full rule lists.
        content:
          type: array
          items:
            oneOf:
              - $ref: '#/components/schemas/AliasPronunciationRule'
              - $ref: '#/components/schemas/PhonemePronunciationRule'
            description: >-
              Base class for pronunciation rules that control how specific text
              is spoken during TTS synthesis. Rules use polymorphic
              serialization with a type discriminator to support different
              pronunciation methods (alias or phonetic).
          description: >-
            Pronunciation rules defining how specific words and phrases should
            be spoken. Each rule specifies text to match and its pronunciation
            using either alias (alternative text) or phonetic representation.
        name:
          minLength: 1
          type: string
          description: >-
            Display name for the pronunciation dictionary. Used to identify and
            organize dictionaries in your account.
        createdTime:
          type: string
          description: Timestamp when the pronunciation dictionary was originally created.
          format: date-time
        lastUpdatedTime:
          type: string
          description: >-
            Timestamp when the pronunciation dictionary was last modified.
            Updates when rules are added, removed, or the name is changed.
          format: date-time
      additionalProperties: false
      description: >-
        Pronunciation dictionary information including rules, metadata, and
        provider details. Contains all data needed to use the dictionary with
        TTS voices and track changes over time.
    ProblemDetails:
      type: object
      properties:
        type:
          type: string
          nullable: true
        title:
          type: string
          nullable: true
        status:
          type: integer
          format: int32
          nullable: true
        detail:
          type: string
          nullable: true
        instance:
          type: string
          nullable: true
      additionalProperties: {}
    AliasPronunciationRule:
      allOf:
        - $ref: '#/components/schemas/PronunciationRuleBase'
        - required:
            - alias
            - type
          type: object
          properties:
            type:
              enum:
                - alias
              type: string
              description: >-
                Rule type discriminator indicating this is an alias-based
                pronunciation rule.
              readOnly: true
            alias:
              minLength: 1
              type: string
              description: >-
                Alternative text to speak instead of the matched text. The TTS
                engine will pronounce this replacement text using its natural
                language processing. For example, "HTTP" could be aliased to "H
                T T P" for letter-by-letter pronunciation, or "SQL" to "sequel"
                for word pronunciation.
          additionalProperties: false
      description: >-
        Alias pronunciation rule that replaces matched text with alternative
        text during TTS synthesis. Useful for expanding acronyms, replacing
        technical terms with pronounceable alternatives, or substituting brand
        names with phonetic spellings. The TTS engine will then pronounce the
        alias text naturally.
    PhonemePronunciationRule:
      allOf:
        - $ref: '#/components/schemas/PronunciationRuleBase'
        - required:
            - phoneme
            - type
          type: object
          properties:
            type:
              enum:
                - phoneme
              type: string
              description: >-
                Rule type discriminator indicating this is a phoneme-based
                pronunciation rule.
              readOnly: true
            phoneme:
              type: array
              items:
                type: string
              description: >-
                List of phoneme symbols representing how the text should be
                pronounced. Each string in the list is a phoneme from the
                specified phonetic alphabet. The TTS engine will synthesize
                these phonemes directly, bypassing its natural language
                processing for precise pronunciation control.
            alphabet:
              type: string
              description: >-
                Phonetic alphabet system used for the phoneme symbols. Supported
                values vary by provider but commonly include "ipa"
                (International Phonetic Alphabet). When not specified, the
                provider's default alphabet is used.
              nullable: true
          additionalProperties: false
      description: >-
        Phoneme pronunciation rule that specifies exact phonetic pronunciation
        for matched text using phonetic alphabet symbols. Provides precise
        control over pronunciation, useful for words that TTS engines commonly
        mispronounce, foreign words, or specialized terminology requiring
        specific pronunciation.
    PronunciationRuleBase:
      required:
        - text
        - type
      type: object
      properties:
        type:
          allOf:
            - $ref: '#/components/schemas/PronunciationRuleType'
          description: >-
            Rule type discriminator determining the pronunciation method.
            Supported values: alias (text replacement), phoneme (phonetic
            representation).
          readOnly: true
        text:
          minLength: 1
          type: string
          description: >-
            Word or phrase to match in the input text. When this text is
            encountered during TTS synthesis, it will be pronounced according to
            the rule's pronunciation specification. Matching is typically
            case-insensitive.
      additionalProperties: false
      description: >-
        Base class for pronunciation rules that control how specific text is
        spoken during TTS synthesis. Rules use polymorphic serialization with a
        type discriminator to support different pronunciation methods (alias or
        phonetic).
    PronunciationRuleType:
      enum:
        - unspecified
        - alias
        - phoneme
      type: string
      description: >-
        Pronunciation rule type determining how matched text is pronounced
        during TTS synthesis. Each type uses a different method to specify
        pronunciation: alias substitutes alternative text, while phoneme uses
        phonetic symbols for precise pronunciation control.
  securitySchemes:
    ApiKey:
      type: http
      description: API Key Authentication (Bearer {key})
      scheme: Bearer
    OAuth:
      type: oauth2
      flows:
        implicit:
          authorizationUrl: https://auth.dasha.ai/connect/authorize
          scopes:
            platform_api: Platform API

````