How to Generate NPC Voice Lines with TTS API?

By NPC Audio Lab editorial team · Updated 2026-11-19

This guide explains how to generate consistent NPC dialogue using our TTS API, designed for indie developers and audio freelancers. You will learn to select appropriate voices, configure requests for game engines, and manage character limits efficiently. The content covers practical workflows for Unity, Unreal, and web implementations, ensuring your characters sound distinct and reliable.

Readers will discover how to handle speed adjustments, multi-language support, and cost estimation for large dialogue trees. We also cover licensing, watermarking, and common integration pitfalls. This page is intended for developers who need a simple, predictable audio generation pipeline without hiring full voice casts or managing complex infrastructure.

How to Generate NPC Voice Lines with TTS API?

Frequently asked questions

What are NPC voice lines?

NPC voice lines are short audio clips representing dialogue for non-player characters in games. Our API generates these as audio files from text input. You send text via POST request and receive the synthesized speech, allowing you to populate your game world with consistent character voices without hiring full voice casts.

How do I choose a voice for my NPC?

Select from eight presets like Aria, Nova, or Atlas. Choose based on character traits: Aria for warm narrators, Felix for energetic promos, or Atlas for neutral news. Each voice supports all 23 languages, so you can match the tone to your character’s personality and ensure consistent audio identity across scenes.

Can I use the same voice for multiple characters?

Yes, you can assign any voice preset to any number of characters. Since voices are synthesized from licensed recordings, you can reuse Aria for multiple friendly NPCs or Atlas for various news anchors. This consistency helps players recognize character types across your game world without needing distinct voice actors for each role.

How long can a voice line be?

Each API request supports up to 4096 characters. This limit allows for substantial dialogue lines while maintaining generation speed. For longer monologues, split the text into chunks under this limit. The API processes requests sequentially, so plan your batch sizes to avoid queuing delays during bulk generation phases.

What is the best audio format for games?

MP3 is efficient for web delivery, while WAV or FLAC offers uncompressed quality for high-fidelity game audio. WAV provides uncompressed quality for short sound effects. OPUS and FLAC are also supported for specific needs. Choose based on your engine’s audio pipeline. PCM is available for raw data processing. All formats are returned directly in the API response.

How do I split long text into voice lines?

Split your text into segments of up to 4096 characters. Generate each segment individually via separate API calls. Then, join the resulting audio files in your game engine or post-production tool. This ensures each chunk is synthesized efficiently without hitting the character limit per request, maintaining consistent audio quality throughout.

Can I change the speed of the voice line?

Yes, adjust the speed parameter between 0.25 and 4.0. This allows you to create slow, thoughtful NPCs or fast-talking characters. Set the speed value in your JSON request body alongside the voice and text. This feature helps differentiate characters without changing the underlying voice preset, adding variety to your dialogue system.

Do I need to specify the language?

It is recommended to specify the language using the ISO code. If omitted, the API guesses the language, defaulting to English for Latin script. For non-English Latin text, explicit language setting ensures accurate synthesis. Supported languages include English, Spanish, Japanese, and 20 others, allowing precise control over pronunciation and accent.

What happens if the API fails?

If synthesis fails, the charge is returned in full. You are not billed for failed requests. This ensures you only pay for successful audio generation. Check the API response status to confirm success or failure. Failed requests do not consume your character quota, protecting your budget during development and testing phases.

How do I integrate this with Unity?

Use standard HTTP requests to POST text to the API endpoint. Parse the JSON response to retrieve the audio file. Load the audio into Unity using standard audio components. You can use the OpenAI SDK by changing the base URL to our API endpoint. This allows seamless integration into your existing game loops.

How do I integrate this with Unreal Engine?

Send POST requests to the API with your text and voice parameters. Receive the audio file in the response. Load the audio into Unreal Engine using standard audio assets. You can use the OpenAI SDK with our base URL for easier integration. This workflow supports dynamic dialogue generation during gameplay without pre-recording all lines.

Are the voices royalty-free?

Voices are based on licensed recordings: LibriTTS-R (CC BY 4.0), from LibriVox public-domain audiobook readings. You can use generated audio in your games without additional royalty payments. The API handles the licensing for the base recordings. Ensure you comply with the CC BY 4.0 terms if required by your distribution channel.

Do I need to attribute the voices?

Attribution is not strictly required by the API terms, though it is appreciated. You are free to credit NPC Audio Lab or omit it entirely in your game’s credits or documentation.

How do I track my usage costs?

Monitor your balance and character usage on the /get-api-key/ dashboard. The API charges $0.01 per 1,000 characters. Track characters consumed per request to estimate costs. Failed requests are free, so only successful generations count. Use the dashboard to view real-time usage and ensure you stay within your budget limits.

What is a rate limit?

The API allows 60 requests per minute per key. Before your first top-up, the limit is 10 requests per minute. This prevents excessive load and ensures fair usage. If you exceed the limit, requests may be delayed or rejected. Plan your bulk generation tasks to stay within these limits for smooth operation.

Can I generate voice lines in bulk?

Yes, you can generate multiple voice lines by sending multiple requests. Split long texts into chunks under 4096 characters. Process them sequentially or in parallel, respecting the rate limit. Use the API key to authenticate each request. This allows you to build large dialogue trees efficiently without manual intervention for each line.

Is real-time generation possible?

Typical speed: roughly real time on long texts (about 25 characters of text per second of generation); short phrases take a few seconds. Requests are processed one after another, so under load a request may wait in a queue.

How do I handle errors in my code?

Check the API response status for success or failure. Handle HTTP errors and parse the JSON response. Implement retry logic for transient failures. Since failed requests are free, you can retry without cost penalties. Use standard HTTP libraries in your language to manage connections and timeouts effectively during integration.

What support is available?

Support is available via email only. There is no live chat or phone support. Check the documentation for integration details. Email support is the primary channel for technical questions. Response times may vary based on volume. Ensure you provide clear details about your API requests when contacting support for faster resolution.

Can I use this for mobile games?

Yes, the API works well for mobile games. Generate audio files during development or on-demand during gameplay. Consider file sizes when choosing formats like MP3 for mobile efficiency. No mobile SDK. This allows dynamic voice lines without pre-recording all content, saving storage space on devices.

Understanding NPC Voice Requirements

Sound wave illustration for: Understanding NPC Voice Requirements

Generating consistent NPC voices requires aligning technical constraints with narrative needs. Unlike human actors, your TTS pipeline must guarantee that a character’s voice remains identical across hundreds of dialogue lines, regardless of length or context.

Consistency relies on selecting a single voice preset per character and maintaining stable input parameters. This approach ensures that players recognize their companions and enemies instantly, without the variability of live casting.

Character Consistency

Assign each NPC a fixed voice preset from the eight available options. Whether using Aria for a wise mentor or Atlas for a news-broadcasting drone, locking the voice ID prevents tonal drift between sessions.

Use the same speed and format settings for all lines belonging to the same character. This uniformity helps audio engines blend lines seamlessly during gameplay transitions.

  • Lock voice ID per character
  • Standardize speed and format

Dialogue Length

Each API request supports up to 4096 characters. Most NPC lines fit within this limit, but longer quest descriptions may require splitting.

Split long texts into segments under the limit, generate each audio file, and join them in your game engine. This ensures no data loss while maintaining playback continuity.

Emotional Tone

Tone is derived from the voice preset and speed settings. For example, Felix offers energetic promo-style delivery, while Luna provides soft storytelling.

Adjust the speed parameter between 0.25 and 4.0 to tweak urgency. Slower speeds suit calm narration, while faster rates suit combat alerts, but extreme values may affect clarity.

Choosing the Right Voice

Sound wave illustration for: Choosing the Right Voice

NPC Audio Lab offers eight distinct voice presets, each grounded in licensed recordings from LibriTTS-R and LibriVox. These voices provide consistent character identities across your game’s dialogue, ensuring that an NPC’s tone remains stable regardless of the specific line being generated. The selection spans warm narrators to energetic promo voices, allowing for clear differentiation between character types.

Male vs Female Options

The female presets include Aria (warm, clear narrator), Nova (bright, upbeat), Luna (soft, storytelling), and Sage (calm, instructional). Male options feature Felix (energetic, promo), Milo (friendly, conversational), Atlas (neutral, news), and Orion (deep, documentary). Each voice is designed for specific narrative roles, from conversational companions to authoritative figures.

  • Aria: Warm, clear narrator
  • Nova: Bright, upbeat
  • Luna: Soft, storytelling
  • Sage: Calm, instructional
  • Felix: Energetic, promo
  • Milo: Friendly, conversational

Neutral and Deep Voices

For characters requiring minimal emotional bias or authoritative presence, Atlas provides a neutral, news-style delivery suitable for exposition or system prompts. Orion offers a deep, documentary tone ideal for lore-heavy NPCs or ancient beings. These voices maintain clarity even in complex dialogue sequences, ensuring the player’s focus remains on the narrative content.

Matching Character Archetypes

Select a voice that aligns with your character’s archetype to enhance immersion. A bright, upbeat voice like Nova suits energetic shopkeepers, while the calm, instructional tone of Sage fits tutorial guides. Ensure the chosen voice supports the character’s personality without requiring extensive post-processing, as the API returns raw audio files ready for integration into your game engine.

Setting Up the API Request

Sound wave illustration for: Setting Up the API Request

Generating NPC speech begins with a straightforward API call. You send text to the endpoint and receive an audio file, mirroring the standard OpenAI structure but pointing to our infrastructure. This simplicity allows indie developers to integrate voice lines without complex middleware or custom SDKs.

Authenticating Your Key

Include your unique key in the header as Authorization: Bearer tts-.... Each account holds one active key; issuing a new one immediately invalidates the previous one. Ensure your key is sent with every request to authenticate usage against your balance.

  • Format: Authorization: Bearer tts-<your_key>
  • One active key per account
  • New keys invalidate old ones instantly

Configuring Base URL

Point your HTTP client to https://api.89999.info/v1. For the speech generation, send a POST request to /audio/speech. This endpoint accepts JSON bodies with model, input, voice, and format parameters, allowing seamless integration with existing game pipelines.

  • Base: https://api.89999.info/v1
  • Endpoint: POST /audio/speech
  • Body: JSON format

Selecting Audio Format

Choose from mp3, wav, opus, flac, or pcm via the response_format field. MP3 is efficient for web delivery, while WAV or FLAC offers uncompressed quality for high-fidelity game audio. PCM provides raw data for custom processing.

  • mp3, wav, opus, flac, pcm
  • MP3 for web efficiency
  • WAV/FLAC for uncompressed quality

Handling Text Input Limits

Sound wave illustration for: Handling Text Input Limits

The API enforces a strict 4096-character limit per request, counting spaces and punctuation. For NPC dialogue exceeding this threshold, you must split the text into segments and process them individually.

Use a loop to send each chunk via POST /v1/audio/speech, then concatenate the resulting audio files. This ensures consistent character counting and avoids truncation errors during synthesis.

4096 Character Limit

Each API call accepts a maximum of 4096 characters for the input field. This limit applies to the raw text string, including all spaces and punctuation marks. Exceeding this length results in a request error, so always validate your dialogue strings before submission.

  • Count spaces and punctuation as characters.
  • Limit is per request, not per session.
  • Validation prevents synthesis errors.

Splitting Long Dialogues

For longer monologues, divide the text into segments of up to 4096 characters. Use your game engine’s script to chunk the dialogue array. Send each segment sequentially to the API endpoint to ensure proper processing order.

  • Divide text into 4096-char chunks.
  • Process segments sequentially.
  • Maintain dialogue order.

Joining Audio Files

After receiving individual audio files for each segment, concatenate them in your game engine. Most engines support audio clip merging or sequential playback. Ensure seamless transitions by aligning the end of one clip with the start of the next.

  • Concatenate clips in-game.
  • Align start/end points.
  • Maintain audio continuity.

Optimizing for Game Engines

Sound wave illustration for: Optimizing for Game Engines

Integrating TTS audio into game engines requires handling dynamic file generation and playback. NPC Audio Lab’s API returns standard audio formats that plug directly into Unity’s AudioSource or Unreal’s Sound Wave components, enabling runtime speech generation without pre-baking every line.

For web-based games, the API’s compatibility with standard HTTP requests allows seamless integration with Web Audio API, ensuring playback for interactive NPC responses in browser environments.

Unity Integration

Use the UnityWebRequest module to POST text to the API endpoint. Parse the returned audio file (mp3 or wav) and assign it to an AudioSource component for immediate playback. This allows for dynamic dialogue generation based on player choices.

Cache generated audio locally if the same line is frequently reused to minimize API calls and reduce latency during gameplay.

  • - Use UnityWebRequest for POST requests
  • - Assign response to AudioSource component
  • - Cache repeated lines for performance

Unreal Engine Integration

Send requests via HTTP modules and store the resulting audio files in temporary directories. Load them into Sound Wave objects for playback. This workflow supports real-time dialogue generation without extensive pre-production voice acting.

Ensure your engine’s networking settings allow POST requests to the API domain to prevent connectivity issues during runtime speech generation.

  • - Use HTTP module for requests
  • - Store files in temporary directories
  • - Load into Sound Wave objects

Web Audio Implementation

Fetch audio data using fetch() or XMLHttpRequest. Decode the response into an ArrayBuffer and create an AudioBufferSourceNode for playback. This method is ideal for browser-based RPGs or interactive fiction games.

Handle asynchronous responses carefully to ensure audio plays in the correct sequence, especially when multiple NPCs respond simultaneously.

  • - Use fetch() or XMLHttpRequest
  • - Decode into ArrayBuffer
  • - Create AudioBufferSourceNode

Managing Audio Speed

Sound wave illustration for: Managing Audio Speed

Adjusting the speed parameter allows you to fine-tune how NPCs deliver their lines, ranging from 0.25 to 4.0. Slower speeds suit calm narration, while faster rates suit combat alerts, but extreme values may affect clarity. This flexibility helps match the character’s personality without requiring separate voice recordings for different emotional states.

The speed setting directly impacts the duration of the generated audio file. Since the API processes requests sequentially, faster generation times can reduce queue wait times during peak usage. However, maintaining a natural pace ensures the dialogue remains intelligible for players, especially in fast-paced game environments.

Speed Factor Range

The API accepts speed values between 0.25 and 4.0, allowing precise control over speech tempo. A value of 1.0 represents the standard delivery rate of the selected voice preset. Values below 1.0 slow down the speech, while values above 1.0 accelerate it, enabling dynamic adjustments for different character types or situational contexts.

You can set the speed parameter in the JSON body of your request alongside the model and voice selection. This allows you to define specific delivery styles for different NPC archetypes, such as a hurried messenger or a slow-speaking elder, directly through the API configuration.

  • Minimum speed: 0.25 (very slow)
  • Standard speed: 1.0
  • Maximum speed: 4.0 (very fast)

Adjusting for Clarity

Slower speeds suit calm narration, while faster rates suit combat alerts, but extreme values may affect clarity. For dense exposition or technical terms, reducing speed to 0.75–0.9 ensures listeners catch every word. Conversely, background crowd noise or action sequences may benefit from slightly faster speeds (1.1–1.3) to keep dialogue concise.

Experiment with different speeds to find the optimal balance between naturalness and efficiency. Faster speech can convey urgency or excitement, while slower speech can emphasize importance or create a contemplative mood. Always test the audio in your game engine to ensure the speed enhances the player experience rather than detracting from it.

  • Use 0.75–0.9 for exposition
  • Use 1.1–1.3 for action sequences
  • Test extreme values for clarity

Impact on Playback

Changing the speed factor alters the duration of the generated audio file, which can affect synchronization with animations or events in your game engine. Longer audio files may require adjustments to timing scripts or trigger conditions to ensure seamless integration into the gameplay loop.

Since requests are processed sequentially, generating audio at faster speeds may reduce the overall time spent in the queue during high-load periods. This can improve the responsiveness of your NPC interactions, especially in scenarios where multiple voice lines are triggered simultaneously by player actions.

Language Selection Strategy

Sound wave illustration for: Language Selection Strategy

Choosing the correct language ensures your NPCs sound authentic, whether they are speaking English or Turkish. The API handles both automatic detection and explicit configuration to match your game's setting.

For most cases, the system guesses the language from the text script. However, for non-English Latin text or mixed scripts, you must explicitly set the language code to avoid mispronunciation.

Automatic Detection

The API attempts to guess the language from the input text. If the language field is omitted, Latin script defaults to English. This works well for standard dialogues but may fail for mixed languages.

This approach simplifies initial implementation, allowing you to generate voice lines quickly without managing language codes for every character.

  • Defaults to English for Latin text

Manual Language Code

For non-English Latin-script text, you should explicitly set the language parameter. This ensures accurate pronunciation for languages like German, Dutch, or Portuguese, which might otherwise be misinterpreted.

Use ISO codes (e.g., de, fr, ja) to target specific voices. All eight voices can speak any of the 23 supported languages, giving you flexibility in casting.

  • Explicit codes ensure accuracy
  • All voices support all 23 languages

Multi-Language Games

When localizing your game, you can generate voice lines in multiple languages using the same voice presets. This maintains character consistency across different regional releases.

Ensure you validate that the target language is in the supported list. Vietnamese, Indonesian, Thai, Ukrainian, Romanian, Czech, Bengali and all others not in the list are not supported.

  • Supports 23 languages
  • Vietnamese, Thai, Ukrainian not supported
Language Selection Strategy

Testing Voice Lines

Sound wave illustration for: Testing Voice Lines

Testing voice lines ensures that generated audio integrates smoothly into your game’s audio pipeline before committing to full production runs. This phase verifies that the synthetic speech meets your design standards for clarity, pacing, and character consistency without wasting credits on unusable assets.

Quality Check

Listen to the output for unnatural pauses or mispronunciations, especially with proper nouns or game-specific jargon. Verify that the selected voice matches the character archetype and that the audio format (mp3, wav, etc.) aligns with your engine’s requirements. Check for inaudible watermarks if required by your licensing terms.

  • Verify clarity and natural pacing
  • Check format compatibility with engine
  • Ensure voice matches character archetype

Latency Testing

Measure the time between your API request and the receipt of the audio file. Short phrases may take a few seconds, while longer texts approach real-time generation speeds (approx. 25 characters per second). Account for network latency and potential queueing under load during peak usage times to ensure smooth gameplay integration.

  • Measure request-to-response time
  • Account for queueing under load
  • Test with typical network conditions

User Feedback

Gather feedback from beta testers or voice actors on how the synthetic voices compare to their expectations. Use this input to adjust speed settings (0.25–4.0) or switch voices if the tone feels too robotic or mismatched for the scene. Iterate quickly to refine the final audio assets.

  • Gather beta tester feedback
  • Adjust speed or voice based on input
  • Iterate to refine audio assets

Cost Estimation for Voice Lines

Sound wave illustration for: Cost Estimation for Voice Lines

Calculating your voice-over budget is straightforward because pricing is tied directly to text length. Every character, including spaces and punctuation, counts toward the total. At $0.01 per 1,000 characters, you can estimate costs by multiplying your script’s character count by 0.00001.

This linear model helps indie developers plan assets without hidden fees. Failed requests are free, so you only pay for successful audio generations. You can track your usage and remaining balance directly in your dashboard.

Character Counting

Include spaces and punctuation in your count. A 4,000-character request is the maximum per call. For longer dialogues, split the text into chunks and join the resulting audio files to maintain consistency.

  • Count every character, including spaces.
  • Maximum 4,096 characters per request.
  • Failed requests incur no charge.

Budget Planning

With a flat rate of $10 per million characters, costs scale predictably. Start with a small batch of voice lines to verify your audio quality and timing before generating your entire game’s dialogue.

No monthly plans or minimum spend means you only pay for what you use. Balance never expires, allowing you to accumulate credits for larger projects or seasonal content updates.

Trial Usage

New accounts signed in with Google receive $0.50 in free trial credit. This covers approximately 50,000 characters, valid for 7 days. It is ideal for testing voice selection and format compatibility.

Email-based accounts do not receive trial credit. Use this period to experiment with different voices and speeds to find the best fit for your NPC archetypes before purchasing USDT top-ups.

Licensing and Rights

Sound wave illustration for: Licensing and Rights

Generated audio files are yours to use commercially within your game or project. The API service grants you the right to incorporate the synthetic speech into your final product without additional per-use fees, provided you have sufficient credit to cover the character consumption.

Commercial Use

You retain full rights to the generated audio assets for internal and commercial distribution. There are no restrictions on using the voices for indie games or commercial titles, as long as the audio is part of a larger creative work.

Attribution Requirements

Attribution is not strictly required by the API terms, though it is appreciated. You are free to credit NPC Audio Lab or omit it entirely in your game’s credits or documentation.

Watermark Usage

Every generated file contains an inaudible watermark identifying it as synthetic speech. This mark is embedded in the audio data and does not affect playback quality or license validity. It serves as a marker of origin but does not impose additional legal burdens on you.

Common Pitfalls

Sound wave illustration for: Common Pitfalls

Developers often hit the 60-requests-per-minute limit quickly when batch-generating lines for large dialogue trees. Without a queue strategy, requests fail or wait, breaking your automation pipeline. Understanding the per-key limit prevents silent failures during mass generation.

Another common error is ignoring the response_format parameter. If your game engine expects WAV but receives MP3, playback breaks. Always match the format to your audio backend’s requirements to avoid runtime errors.

Rate Limit Exceeded

The API enforces a strict limit of 60 requests per minute per key. If you exceed this, requests may queue or fail. For large NPC casts, implement a simple retry mechanism with exponential backoff.

New accounts start with only 10 requests per minute. Scale up your throughput by topping up your balance to ensure consistent generation speeds during development sprints.

  • Monitor your usage dashboard for real-time limit tracking.
  • Use a single key for all batch jobs to avoid splitting limits across multiple tokens.
  • Implement client-side queuing to smooth out burst traffic.

Incorrect Format

Selecting the wrong response_format (e.g., opus when your engine needs wav) leads to playback errors. Always verify the format supported by your Unity or Unreal Audio component before sending requests.

The API returns raw audio bytes. Ensure your HTTP client correctly handles binary responses without adding extra headers or modifying the byte stream, which can corrupt the file.

  • Test with pcm format for raw, uncompressed debugging.
  • Validate format support in your game engine’s audio loader.
  • Always check the Content-Type header in the response.

Text Encoding Issues

Non-ASCII characters in dialogue can cause silent failures if not properly UTF-8 encoded. Ensure your JSON payload uses standard UTF-8 encoding, especially for languages like Arabic, Chinese, or Russian.

Special characters like quotes or em-dashes are counted as characters. Verify that your text preprocessing strips or escapes these correctly to avoid unexpected character count inaccuracies or parsing errors.

The API does not support custom pronunciation lexicons. If a character is mispronounced, you must manually adjust the spelling in the input text field before sending the request.

  • Use UTF-8 for all JSON payloads.
  • Escape special characters in your programming language’s JSON library.
  • Manually adjust spelling for edge-case pronunciations.

Support and Resources

Sound wave illustration for: Support and Resources

Support for NPC Audio Lab is handled exclusively via email. There is no live chat or phone number available, so direct calls are not an option. All inquiries, including billing issues or technical questions, are managed through this single channel.

Since we do not offer an SLA, response times may vary depending on volume. We recommend checking the documentation first, as most common integration questions are already answered there.

Email Support

Send your questions to [email protected]. Include your API key and a description of the issue. We do not have a ticketing system, so please keep your email thread concise.

Documentation Links

The official documentation is available at https://89999.info/docs/. It covers the API endpoint structure, voice presets, and code examples for Unity and Unreal Engine.

You can also view available voices and models at https://89999.info/get-api-key/ after signing in.

  • https://89999.info/docs/
  • https://89999.info/get-api-key/

Community Resources

We do not maintain a dedicated forum or Discord server. Indie developers often share integration tips in broader game dev communities like r/gamedev or Unity Forums.

You can also find code snippets on GitHub by searching for 'NPC Audio Lab API' or '89999.info TTS'.

  • r/gamedev
  • Unity Forums
  • GitHub search: 'NPC Audio Lab API'

Listen to the 8 voices

Each sample below was generated by this API from the same sentence. This ensures consistent voice delivery across extended conversations without hitting request limits.

Avatar of the voice aria
ariafemale
Avatar of the voice nova
novafemale
Avatar of the voice luna
lunafemale
Avatar of the voice sage
sagefemale
Avatar of the voice felix
felixmale
Avatar of the voice milo
milomale
Avatar of the voice atlas
atlasmale
Avatar of the voice orion
orionmale

23 languages

Any voice speaks any of these languages.

Sources and further reading

  1. Wikipedia
  2. Creative Commons Attribution 4.0
  3. IETF RFC 7845: Ogg Opus
  4. Tether (USDT)
  5. ISO 639 language codes
  6. Python documentation
  7. openai-python on GitHub
  8. LibriTTS-R paper (arXiv 2305.18802)
  9. LibriVox public-domain audiobooks
  10. FFmpeg documentation
  11. OpenAI API reference: create speech
  12. TRON developer hub: TRC-20

More on this site