BakBak

BakBak is a proprietary multilingual text-to-speech system developed by Litwiz Labs for low-latency, natural-sounding conversational speech, with a particular focus on Indian languages and real-time voice applications.

Unlike general-purpose speech generation systems primarily optimized for audiobooks, dramatic narration, or studio production, BakBak is designed around interactive conversations: voice AI agents, IVR systems, customer support, transactional calls, appointment workflows, order tracking, lead qualification, notifications, and other applications where response latency, intelligibility, conversational pacing, and telephony compatibility matter.

BakBak is commercially available through the Raya/BakBak hosted API. Model weights, training code, internal model architecture, and proprietary training datasets are not distributed through this Hugging Face repository.

Model Description

BakBak converts text into speech and is optimized for applications in which generated speech is part of a live or near-live interaction.

The system is designed around several practical requirements of production conversational AI:

Low time-to-first-audio for interactive voice applications
Natural conversational prosody
Indian-language speech synthesis
Hinglish and mixed-language conversational speech
Multiple speaker voices
Streaming synthesis
Integration with voice-agent systems and real-time applications

The product is intentionally positioned differently from narration-first TTS systems. Its principal objective is to generate speech that works effectively inside conversations, rather than maximizing dramatic expressiveness for audiobooks, character acting, dubbing, or cinematic narration.

Model Family

The production API currently exposes two synthesis model identifiers:

Model	Description
`standard`	Default BakBak serving model
`m1`	Alternate/newer BakBak model family exposed through the API

Voices are model-specific. A voice returned for standard must be used with model="standard", while an m1 voice must be used with model="m1".

Applications should not hard-code assumptions about the available voice catalog. Query the voices endpoint and use the model field returned with each voice.

Supported Languages

The current TTS API exposes the following language codes:

API code	Language
`hi`	Hindi
`mr`	Marathi
`te`	Telugu
`kn`	Kannada
`bn`	Bengali
`as`	Assamese
`gu`	Gujarati
`ne`	Nepali
`ml`	Malayalam
`ta`	Tamil
`pa`	Punjabi
`en-in`	Indian English
`en-us`	US English

Language availability may evolve independently of this model card. Applications should consult the current Raya API documentation before relying on a specific language in production.

Voices

BakBak provides multiple voices.

The voice catalog is dynamic and should be retrieved through:

GET https://hub.getraya.app/v1/voices

Authentication is provided using the X-API-Key request header.

A voice object identifies at least:

Voice ID
Voice name
Language
Associated synthesis model

Conceptually:

{
  "id": "<voice-id>",
  "name": "<voice-name>",
  "language": "hi",
  "model": "m1"
}

Important: Model/Voice Compatibility

Voice IDs are model-specific.

Do not assume that a voice selected for one synthesis model can be reused with another.

Correct:

{
  "voice_id": "<m1-voice-id>",
  "model": "m1"
}

Incorrect:

{
  "voice_id": "<standard-voice-id>",
  "model": "m1"
}

When switching synthesis models, retrieve the current voice catalog again.

Inference

BakBak is accessed through authenticated hosted inference.

Base TTS API:

https://hub.getraya.app/v1

Authentication:

X-API-Key: <YOUR_API_KEY>

API keys should be stored server-side or in an appropriate secrets manager and must not be embedded directly in public client applications or source repositories.

Discover Available Voices

curl --request GET \
  --url https://hub.getraya.app/v1/voices \
  --header 'X-API-Key: <YOUR_API_KEY>'

Applications should normally select a voice from this response instead of relying on a voice identifier copied from documentation or an older integration.

Non-Streaming Synthesis

Endpoint:

POST https://hub.getraya.app/v1/text-to-speech

Example:

curl --request POST \
  --url https://hub.getraya.app/v1/text-to-speech \
  --header 'Content-Type: application/json' \
  --header 'X-API-Key: <YOUR_API_KEY>' \
  --data '{
    "text": "आपकी समस्या समझ आ गई है। मैं आपकी मदद करती हूँ।",
    "voice_id": "<VOICE_ID>",
    "model": "m1",
    "language": "hi",
    "codec": "wav",
    "sample_rate": 24000,
    "speed": 1.0
  }' \
  --output response.wav

The non-streaming endpoint generates the complete utterance before returning the finished audio response.

It is appropriate for applications such as:

Pre-generated prompts
Batch synthesis
Cached phrases
Offline workflows
Notifications
Content pipelines
Situations where a complete audio file is required

Streaming Synthesis

Endpoint:

POST https://hub.getraya.app/v1/text-to-speech/stream

The current API reference describes this endpoint using Server-Sent Events (SSE).

Audio is delivered incrementally, allowing playback to begin without waiting for synthesis of the complete utterance.

Streaming events conceptually follow:

event: chunk
data: {
  "type": "chunk",
  "status_code": 206,
  "done": false,
  "data": "<base64-audio>",
  "step_time": 0.123
}

event: done
data: {
  "type": "done",
  "status_code": 200,
  "done": true
}

Streaming chunks are documented as base64-encoded PCM F32LE audio.

Because API transports and serving infrastructure can evolve, production integrations should treat the current Raya API reference as the source of truth for streaming protocol details.

Input Parameters

`text`

Text to synthesize.

"text": "नमस्ते! मैं आपकी कैसे सहायता कर सकती हूँ?"

`voice_id`

Identifier of an available Raya voice.

Retrieve current voice IDs from /v1/voices.

`model`

Currently documented synthesis models:

standard
m1

Default:

standard

`language`

Language code corresponding to the synthesis request.

Example:

"language": "hi"

`codec`

For non-streaming output, the API supports:

wav
mp3
pcm
mulaw

`sample_rate`

Supported output sample rates include:

8000 Hz
16000 Hz
22050 Hz
24000 Hz

`speed`

Speech-rate multiplier:

0.5 – 1.5

Default:

1.0

Intended Use

Primary Intended Uses

BakBak is designed primarily for conversational speech synthesis, including:

Voice AI Agents

Real-time AI agents that speak to users over phone, web, mobile, or other voice interfaces.

Examples include:

Customer-support agents
Appointment-booking assistants
Order-status agents
Lead qualification
Customer onboarding
Sales assistance
Survey and feedback agents
Collections or payment reminders, where legally permitted
Information hotlines
Internal enterprise voice assistants

IVR and Telephony

BakBak supports output configurations suitable for telephony, including lower sample rates and μ-law audio.

Typical applications include:

Interactive voice response systems
Contact centers
Automated customer-service calls
Call routing
Transactional notifications
Status updates
Phone-based conversational applications

Real-Time Conversational Interfaces

Streaming synthesis allows applications to begin audio playback before the complete utterance has been generated.

This is particularly useful when TTS operates downstream from an LLM, where the overall interaction may involve:

User speech → STT → LLM → BakBak → Audio

Reducing synthesis startup latency helps minimize unnatural gaps between conversational turns.

Multilingual Indian Applications

BakBak is intended for applications serving multilingual users in India and surrounding language communities.

It is particularly suited to products in which users naturally switch between English and Indian languages rather than speaking in a single standardized language throughout an interaction.

Out-of-Scope / Non-Primary Uses

BakBak is not primarily optimized for:

Audiobook production
Long-form narration
Movie or television dubbing
Character acting
Highly theatrical speech generation
Singing or music generation
Sound-effect generation
Speech recognition
Speaker identification
Speaker verification

The system may technically generate speech for some longer-form content, but those applications are not its principal optimization target.

For long-form narration, evaluate output quality and consistency against a narration-specific system before production use.

Code-Switching and Hinglish

BakBak is designed with Indian conversational speech in mind, including Hinglish and mid-sentence language switching.

For example:

Sir, आपका order almost ready है, बस एक quick confirmation चाहिए.

This type of mixed-language utterance is common in customer support, commerce, banking, logistics, appointment scheduling, and other conversational applications in India.

Code-switching quality can depend on:

Script choice
Voice
Language setting
Named entities
Numbers
Acronyms
Domain terminology
Sentence structure

Applications using heavy code-switching should test representative production conversations rather than relying exclusively on isolated demo sentences.

Text and Script Guidance

Input normalization has a significant effect on TTS quality.

Hindi

When synthesizing Hindi with language="hi", use Devanagari script.

Recommended:

नमस्ते, मैं आपकी कैसे सहायता कर सकती हूँ?

Not recommended for Hindi synthesis:

Namaste, main aapki kaise sahayata kar sakti hoon?

Romanized Hindi is not the preferred input representation for the Hindi synthesis path and may produce substantially worse pronunciation.

Indian Named Entities in English

For Indian names and place names inside English speech, pronunciation may improve when the Indic named entity itself is represented in its native/Devanagari form.

For example:

Less reliable:

Please welcome Rahul from Mumbai.

Potentially more accurate:

Please welcome राहुल from मुंबई.

This technique can be particularly valuable when text is generated dynamically by an LLM.

For production voice agents, consider adding an LLM-to-TTS text normalization stage that prepares:

Personal names
City names
Brand names
Acronyms
Currency
Dates
Phone numbers
Product codes
Addresses
Domain-specific terminology

before sending the final utterance to BakBak.

Voice Cloning

The broader BakBak product supports consent-based voice cloning for authorized use cases.

Voice cloning should only be performed when the person whose voice is being cloned has provided appropriate, explicit authorization for the intended use.

A cloned voice must not be treated as authorization to:

Impersonate an individual deceptively
Circumvent authentication
Commit fraud
Misrepresent the identity of a caller
Create deceptive political or financial communications
Generate non-consensual intimate or abusive content
Falsely imply endorsement by a real person

Voice cloning may be subject to additional product, contractual, legal, and verification requirements beyond the core TTS endpoint described in this card.

Audio Configuration

Different applications have different audio requirements.

24 kHz

Recommended when speech quality is the primary concern and bandwidth is not heavily constrained.

Typical applications:

Web voice assistants
Mobile applications
High-quality conversational interfaces

16 kHz

Useful compromise between bandwidth and quality.

Typical applications:

Real-time communications
Speech-processing pipelines
Bandwidth-sensitive applications

8 kHz

Useful for traditional telephony.

Typical applications:

PSTN calls
IVR
Contact-center systems
Bandwidth-constrained telephone audio

WAV

Useful for lossless or workflow-oriented audio where file size is not the primary constraint.

MP3

Useful where compressed audio distribution or storage is desirable.

PCM

Useful when raw audio is consumed directly by downstream audio or real-time processing infrastructure.

μ-law

Useful in telephony pipelines and systems expecting μ-law encoded audio.

Latency

BakBak is engineered for low-latency conversational inference and operates under 150 ms time-to-first-byte in streaming scenarios.

This figure should be interpreted as a product/service performance target rather than a universal end-to-end guarantee.

Observed latency depends on factors including:

User-to-server network latency
Geographic location
Input length
Selected model
Selected voice
Current service load
Connection reuse
Application architecture
Audio buffering
Client-side playback
LLM generation strategy upstream of TTS

The end-user experience should be evaluated using full conversational latency rather than TTS inference latency alone.

Conversational Text Generation Guidance

When using BakBak behind an LLM, the upstream language model should generate spoken language, not prose intended for reading.

Prefer:

जी, आपका order मिल गया है। यह कल शाम तक पहुँच जाना चाहिए।

over:

We have successfully retrieved your order information from our system. According to the latest available tracking data, the estimated delivery date is tomorrow evening.

For voice-agent applications, prompts should generally encourage:

Short sentences
Natural contractions where appropriate
Spoken-number formatting
Minimal unnecessary punctuation
Limited parenthetical information
Conversational vocabulary
Explicit pronunciation handling for unusual names
Responses broken into speakable semantic units

This can improve both latency and naturalness.

Performance Characteristics

BakBak is optimized primarily around the requirements of conversational systems:

Characteristic	Design emphasis
Conversational naturalness	High
Low startup latency	High
Indian-language support	High
Code-switching	High
Telephony integration	High
Streaming	High
Long-form narration	Not primary target
Dramatic acting	Not primary target
Studio dubbing	Not primary target
Singing	Unsupported / not intended

Training Data

BakBak is a proprietary model.

Detailed information about the model's training corpus is not disclosed in this public model card.

Model Weights and Reproducibility

This repository is intended to provide model documentation and discoverability, not downloadable model weights.

It therefore does not provide:

Checkpoints
Training scripts
Fine-tuning scripts
Tokenizers or internal speech codecs required to reproduce the service

Inference is performed through infrastructure operated or authorized by Litwiz Labs.

Limitations

Like all neural text-to-speech systems, BakBak can produce imperfect speech.

Potential limitations include:

Proper Nouns

Rare personal names, company names, geographic locations, and newly coined words may be pronounced incorrectly.

Romanized Indic Text

Romanized Hindi is not the recommended representation for Hindi synthesis and may produce degraded output.

Ambiguous Text

Text such as:

12/04/26

may have multiple spoken interpretations.

Normalize ambiguous inputs before synthesis.

Numbers and Identifiers

Phone numbers, account numbers, dates, decimal values, currencies, addresses, and alphanumeric identifiers may require text preprocessing for the intended pronunciation.

Acronyms

Unfamiliar acronyms may be pronounced as words when spelling would be preferable, or vice versa.

Regional Variation

Languages contain significant regional, dialectal, sociolectal, and accent variation. A supported language code does not imply equivalent performance across every speaker community.

Code-Switching Variability

Although conversational code-switching is a design focus, performance can vary with:

Script
Switching frequency
Word origin
Voice selection
Sentence structure
Domain-specific terminology

Long-Form Prosody

The model is primarily optimized for conversational turns rather than chapter-length narration. Very long synthesis inputs may not exhibit the same prosodic consistency expected from narration-specific systems.

Network Dependency

Hosted inference requires network connectivity and therefore introduces infrastructure and network-related failure modes that do not apply to fully local models.

Bias, Fairness, and Representation

Speech systems can perform differently across:

Languages
Dialects
Accents
Regions
Age groups
Gender presentations
Speaking styles
Vocabulary domains
Socioeconomic and cultural contexts

Support for a language should not be interpreted as proof of uniform performance across every community that speaks that language.

Deployers should evaluate BakBak using samples representative of their actual users.

For high-volume applications, evaluation sets should include:

Multiple regions
Different name distributions
Local place names
Different English/Indic mixing patterns
Domain terminology
Different sentence lengths
Numbers and currencies
Common customer-service phrases
Edge-case pronunciation

Users should have a way to report systematically incorrect or offensive pronunciation.

Responsible Use

Synthetic speech can be beneficial, but it can also be misused.

BakBak should be deployed with appropriate safeguards for the application.

Appropriate Uses

Examples include:

Authorized customer-service automation
Accessibility
Voice interfaces
IVR
Transactional notifications
Educational applications
Authorized branded voices
Enterprise voice agents
Internal productivity systems

High-Risk or Inappropriate Uses

Do not use the system to facilitate:

Fraud
Identity theft
Non-consensual impersonation
Voice-authentication bypass
Deceptive financial solicitation
Harassment
Extortion
Social engineering
Fabricated emergency communications
Unauthorized cloning of a person's voice

Applications capable of contacting users autonomously should comply with applicable telecommunications, consent, consumer-protection, privacy, and automated-calling regulations.

Voice Cloning Safety

When using cloned voices, developers should maintain evidence of appropriate speaker authorization.

Recommended controls include:

Obtain explicit speaker consent.
Record the scope of permitted use.
Restrict access to cloning functionality.
Protect uploaded reference audio.
Log creation and use of cloned voices.
Prevent unauthorized export or reuse.
Provide a revocation mechanism where applicable.
Clearly identify synthetic or automated callers where required.
Avoid cloning public figures or third parties without appropriate authorization.
Review relevant laws and contractual obligations before deployment.

Data Handling and Privacy

Raya's API data is processed in India and that customer API inputs are not used for model training.

Security Considerations

API keys provide access to the hosted service.

They should:

Never be committed to source control
Never be included in public Hugging Face files
Never be exposed in browser-side JavaScript
Be stored in a secret manager or environment variable
Be rotated if accidentally disclosed
Be scoped or isolated by environment where supported

Example:

import os

RAYA_API_KEY = os.environ["RAYA_API_KEY"]

Applications should also implement:

Request timeouts
Retry policies
Exponential backoff
Rate-limit handling
Connection pooling
Logging without sensitive plaintext
Appropriate monitoring and alerting

Failure Handling

Applications should gracefully handle common service conditions including:

Invalid API key
Invalid input
Unsupported sample rate
Unknown voice ID
Voice/model mismatch
Rate limiting
Service errors
Network timeouts

Typical HTTP statuses may include:

Status	Meaning
`200`	Successful request
`400`	Invalid request / validation failure
`401`	Missing or invalid authentication
`404`	Requested resource such as a voice not found
`429`	Rate limit exceeded
`500`	Server-side error

Applications should avoid repeatedly retrying invalid 400 requests and should use backoff when retrying temporary service or rate-limit failures.

Commercial Availability

BakBak is a proprietary commercial service.

Access includes hosted API usage and, subject to separate commercial arrangements, enterprise deployment options.

Refer to the current Raya commercial documentation or contact Litwiz Labs for applicable terms.

License

BakBak is proprietary software and model technology.

Citation

BakBak is a commercial proprietary model and no academic citation is required unless separately specified by Litwiz Labs.

If referencing the system in a paper, benchmark, article, or technical report, a descriptive citation may use:

@software{raya_tts,
  title        = {BakBak},
  author       = {{Litwiz Labs}},
  description  = {Proprietary multilingual text-to-speech system for conversational voice applications},
  url          = {https://getraya.app/bakbak}
}

Documentation and Resources

Product:

https://getraya.app/bakbak

API documentation:

https://docs.litwizlabs.com/

TTS API reference:

https://docs.litwizlabs.com/api-reference/text-to-speech/text-to-speech

Voice discovery:

GET https://hub.getraya.app/v1/voices

Non-streaming synthesis:

POST https://hub.getraya.app/v1/text-to-speech

Streaming synthesis:

POST https://hub.getraya.app/v1/text-to-speech/stream

Model Card Notes

This model card describes the BakBak proprietary model/service family rather than an independently downloadable checkpoint.

API behavior, voice availability, languages, models, and serving capabilities may evolve over time. The current Raya API documentation should be treated as authoritative for integration details.

Summary

BakBak is a proprietary, production-oriented TTS system built for fast, multilingual conversational speech.

Its key characteristics are:

Conversational TTS rather than narration-first TTS
Indian-language focus
Indian English
Hinglish and code-switching support
Real-time streaming synthesis
Low-latency voice-agent use cases
Model-specific voice catalogs
standard and m1 serving models
WAV, MP3, PCM, and μ-law support
8 kHz through 24 kHz output options
Configurable speech rate
Telephony-oriented deployment
Consent-based voice-cloning capabilities within the broader platform
Proprietary hosted inference
No public distribution of model weights

BakBak is intended for developers and organizations building practical voice experiences where conversation quality, latency, Indian-language coverage, and production integration matter more than theatrical speech generation.

Downloads last month: -; Downloads are not tracked for this model. How to track