Hume AI alternative · Voice emotion and behavioral signals API
Keep your stack. Add Behavioral Intelligence.
Moving off Hume Expression Measurement, or rebuilding an EVI agent before Nov 13? As a drop-in replacement for the Hume API for speech, the Behavioral Signals API estimates expressed emotion, strength, positivity, stress, confidence, hesitation, engagement and speaking rate from voice, per utterance, with a probability for every class. Your AI agents, LLM workflows and applications keep running; they read those signals through the API.
You change the analysis layer, not the product around it: a new API call, a remapped response, and thresholds re-fitted on your own audio.
New accounts include 30 free minutes of behavioral batch processing. No credit card or sales call needed.
Hume status
Last reviewed:
- Hume’s legacy Expression Measurement API ended in mid-June 2026 (Hume’s SDK release notes cite a 6/15/2026 sunset).
- On Oct 6, 2026, Hume launched a new Expression Measurement API in limited release, with access through its sales team. See Hume’s product page.
- Hume EVI and TTS API access ends Nov 13, 2026 at 12:01 a.m. EST, and account data is permanently deleted after that date.
Connects to your stack through REST, a Python SDK and gRPC streaming
- LLMs
- AI Agents
- Voice platforms
- Contact Center Platforms
- Custom Applications
Behavioral Signals is an API. It feeds signals to these systems through your code; it does not imply a native integration with any named vendor.
Hume AI alternative: quick answers
01What is the best Hume AI alternative for speech emotion?
If you used Hume to measure emotion in speech, choose a replacement by the signals your product actually reads. For emotion and behavior, Behavioral Signals analyzes voice only and returns, for each utterance, a probability for every class of emotion (happy, angry, sad, neutral), strength, positivity, stress, confidence, hesitation, engagement and speaking rate, plus estimated age band and gender, and voice deepfake detection. It runs as a batch API or as real-time gRPC streaming, in the cloud, customer-hosted or at the edge. It does not cover facial-expression, text or vocal-burst models, or speech generation.
02How do I migrate from Hume Expression Measurement?
List the Hume dimensions and thresholds your code depends on. Map each one by meaning to Behavioral Signals classes (anger, sadness and joy map directly; some dimensions, such as nostalgia, have no equivalent). Swap the client to the v5 REST API or the Python SDK, move any live WebSocket path to gRPC streaming with 16-bit linear PCM, and then re-fit your thresholds on your own recordings before cutting over.
03Does Behavioral Signals replace Hume EVI?
It replaces one piece of EVI: the step that estimates expressed emotion and related signals from the caller’s voice and passes them to the language model. Hume EVI and TTS API access ends November 13, 2026 at 12:01 a.m. EST, so EVI teams also need their own speech-to-text, LLM, text-to-speech and turn-taking. Behavioral Signals streams emotion and behavior signals that your code can add to the LLM prompt or use to trigger rules, such as escalating a call to a person when the signals you choose cross a threshold.
Is this you?
Already using Hume Expression Measurement
You send recorded or live speech for expression analysis, most often through the Speech Prosody model, and your product reads the scores. You want the signals back without rebuilding the application around them.
Already have your AI stack
Keep your LLM, AI agent, voice platform, application logic and user experience. Add Behavioral Signals where your product needs to know how something was said, not only what was said.
Need emotion and behavior from voice
Estimate expressed emotion, strength, positivity, stress, confidence, hesitation, engagement and speaking rate per utterance, and feed them into the models, agents and workflows that act on them.
Running a Hume EVI agent
You run an EVI voice agent and need the emotion layer back before Nov 13. Keep your own speech-to-text, LLM and voice, and add per-utterance emotion and behavior signals. Replace only the emotion step →
If any of that sounds familiar, this page is for you.
Why teams make the switch
One API that turns human voice into behavioral, emotional and speaker signals you can act on.
Behavioral intelligence built for production applications.
Per-utterance estimates from recorded or live audio, returned in a structured format your code can route, store and act on. The models run directly on raw audio.
Built for the architecture you already have.
Call it over REST from any language, through the Python SDK, or over gRPC for live audio. Your LLM, agent, voice platform and business logic stay as they are.
Real-time and batch.
Stream live audio for emotional and behavioral signals as the conversation happens, or send recordings in batch. Speaker diarization and ASR are included at no extra charge.
Probabilities, not just labels.
Every classified output returns a probability for each class, so your application sets the threshold at which it acts.
Deployment choice.
The same models run as a cloud API, in customer-hosted deployments and at the edge, in batch and streaming.
Deepfake detection when you need it.
Add speaker-agnostic voice deepfake detection to workflows where trusting the voice matters as much as understanding it.
A behavioral intelligence layer, not a new platform
Behavioral Signals sits between your audio and the systems you already run. Send recordings or live audio, and get back per-utterance estimates of emotion and behavior, in a structured format your software can read directly. Your LLM, AI agent, product or analytics uses those signals, and your own logic decides what happens next.
Voice and audio
Recorded files or a live stream
Speech-to-text
Your STT
LLM or AI agent
Your model and prompts
Text-to-speech
Your TTS and turn-taking
Emotion and behavior sensing
Batch over REST or the Python SDK · real-time over gRPC
Per-utterance signals
Added to your LLM prompt or used to trigger rules
Your existing workflow, UX and business logic
Thresholds, rules and decisions stay in your application
Quickstart
Send one recording you already sent to Hume
Every new account includes 30 free minutes of behavioral batch processing, so you can run your own audio through before adding any credit. The SDK needs Python 3.10 or later. The REST interface is language-agnostic and covers everything the SDK does.
1
Get a key
Create an account, verify your email, and issue an API key. The portal shows your client ID next to it.
2
Install and set credentials
Install the SDK and export your client ID and API key.
3
Send a recording and read the result
Upload one file, wait for the process to finish, and print what comes back.
Step 2. Install and set credentials
pip install behavioralsignals
export BEHAVIORALSIGNALS_CID=<your-client-id>
export BEHAVIORALSIGNALS_API_KEY=<your-api-key>Step 3. Send a recording and read the result
from behavioralsignals import Client
from behavioralsignals.utils import print_results
client = Client()
process = client.behavioral.upload_audio(file_path="call.wav")
result = client.behavioral.wait_for_result(pid=process.pid, timeout=600)
print_results(result.results)Client() reads those two environment variables. To pass credentials in code instead, use Client("your_cid", "your_api_key"). Over REST, the key goes in the X-Auth-Token header, and the client ID goes in the path, replacing Hume’s X-Hume-Api-Key.
The developer reference has a live console on every endpoint, so you can call the API straight from the docs page.
What changes when you migrate
If your application already sends voice to Hume for analysis, much of your surrounding architecture can remain in place.
1. Keep your audio sources.
The recordings and live audio you capture today stay where they are. Recorded files go to a new batch endpoint. Live paths move from Hume’s WebSocket to gRPC streaming with 16-bit linear PCM.
2. Change the API call.
Swap the Hume client for a Behavioral Signals API key and client ID, then call the REST API or the Python SDK. Each recording is one process you submit, poll and read.
3. Remap the response.
Results arrive as a flat list, one entry per task per utterance, with start and end times, class probabilities and a final label. Group them by utterance, then map the Hume dimensions your product reads to Behavioral Signals classes.
4. Re-fit on your own audio.
A Hume score and a Behavioral Signals probability mean different things, so a threshold tuned on one does not carry over. Re-express each rule over the mapped signals and fit its threshold on your own labeled audio.
Hume Expression Measurement (legacy batch API)
curl -X POST https://api.hume.ai/v0/batch/jobs \
-H "X-Hume-Api-Key: $HUME_API_KEY" \
-H "Content-Type: application/json" \
-d '{"urls": ["https://example.com/call.wav"],
"models": {"prosody": {"granularity": "utterance"}}}'Behavioral Signals API
curl -X POST \
"https://api.behavioralsignals.com/v5/clients/$BEHAVIORALSIGNALS_CID/processes/audio" \
-H "X-Auth-Token: $BEHAVIORALSIGNALS_API_KEY" \
-F file=@call.wavOr with the Python SDK
from behavioralsignals import Client
client = Client() # reads your client ID and API key from the environment
process = client.behavioral.upload_audio(file_path="call.wav")
result = client.behavioral.wait_for_result(pid=process.pid, timeout=600)The submit call returns a process ID (pid). You read results from /processes/{pid}/results, or let the SDK wait for them. This example uploads the file; the API also accepts an S3 signed-URL submission.
Running a Hume EVI agent? Replace only the emotion-sensing step
Hume EVI and TTS API access ends 13 November 2026. Keep the rest of your new stack, and add back the part that hears how the caller feels.
When Hume EVI uses a supplemental LLM, it transcribes the user, extracts prosody “expression measures,” converts them to text, and sends both to the language model. After 13 November you rebuild that pipeline yourself: speech-to-text, LLM, text-to-speech and turn detection, or a realtime speech model.
Behavioral Signals supplies the expression-measures part. Stream the caller’s audio, take each utterance’s emotion and behavior labels, and add them to your LLM’s context. Keep your own speech-to-text, LLM and TTS.
from behavioralsignals import Client, StreamingOptions
from behavioralsignals.utils import make_audio_stream
client = Client() # reads BEHAVIORALSIGNALS_CID / BEHAVIORALSIGNALS_API_KEY
audio_stream, sample_rate = make_audio_stream("caller.wav", chunk_size=0.25)
options = StreamingOptions(sample_rate=sample_rate, encoding="LINEAR_PCM", level="utterance")
caller_state = {}
for response in client.behavioral.stream_audio(audio_stream=audio_stream, options=options):
for r in response.results or []:
if r.task in ("emotion", "strength", "positivity", "hesitation", "engagement", "speaking_rate"):
caller_state[r.task] = r.finalLabel
# Pass to your own LLM, e.g. as a system note for the next turn:
note = "Caller voice signals: " + ", ".join(f"{k}={v}" for k, v in caller_state.items())Then add the note to your prompt, for example {"role": "system", "content": note}.
Example policy: if emotion=angry and strength=strong on two or more consecutive utterances, offer a handoff to a human. This is an example rule you write in your own code, not a product feature.
Not using Python? Call the gRPC service directly: BehavioralStreamingApi, rpc StreamAudio (and DeepfakeDetection) at streaming.behavioralsignals.com:443. The first AudioStream message carries cid, x_auth_token and config (encoding=LINEAR_PCM, sample_rate_hertz, optional level); later messages carry audio_content. See the proto file, the bare gRPC client guide and streaming with the Python SDK.
What you still need from other providers
- Speech-to-text
- LLM
- Text-to-speech and voice (Hume voice IDs don’t transfer)
- Turn-taking and interruption handling
- Tools and session handling
Your Hume migration path
Already using Hume Expression Measurement? Here is the practical path to evaluating Behavioral Signals and moving over, without rebuilding the rest of your application.
If you stored Hume outputs, run the same recordings through Behavioral Signals and compare. If you did not, your own labeled audio is the benchmark.
What the Migration Guide gives you: Field-by-field request and response mapping · A mapping for each of Hume’s 48 speech prosody dimensions · Before and after code for batch, parsing and streaming · A validation method · A cut-over checklist
Using Hume EVI or TTS? Hume says access ends 13 November 2026. Behavioral Signals analyzes speech and does not replace either. Read Hume’s notice.
Evaluate on your own audio
Published benchmarks often score every vendor on a shared 7-class label set. Behavioral Signals natively returns 4 emotion classes plus separate strength, positivity and behavioral dimensions, so a 7-class test has to fold or drop classes, and that affects the result. Use benchmarks to shortlist, then decide on your own audio.
- Pick representative recordings. Use consented audio that reflects your real traffic.
- Declare your label mapping first. Write down how Hume dimensions map to Behavioral Signals classes before you look at any results.
- Run the same files through both. Use your current provider, or your stored Hume outputs, and Behavioral Signals.
- Compare decisions, not just accuracy. Check what your application would do per utterance, not only top-1 accuracy.
- Re-fit thresholds and check edge cases. Look at short utterances (under about 1 second), crosstalk and phone-line audio.
New accounts include 30 free minutes of behavioral batch processing. Keep your stored Hume outputs so you can compare side by side.
Hume Expression Measurement alternative: what carries over
Behavioral Signals covers Hume’s speech-prosody workload with fewer, calibrated classes plus behavioral, speaker and deepfake outputs. It doesn’t cover face, text or vocal-burst models, or speech generation. Rows marked “— No equivalent” have no match on that side.
| Capability | Hume Expression Measurement (legacy, ended June 2026)* | Behavioral Signals |
|---|---|---|
| Speech emotion | 48 prosody dimensions, each scored independently | Probability for each of 4 emotion classes (happy, angry, sad, neutral) |
| Strength and positivity | Partial: not separate outputs | Separate strength and positivity classes, with probabilities |
| Hesitation, engagement, speaking rate | — No equivalent | Per-utterance classes |
| Age and gender | — No equivalent | Per speaker (batch) or per segment (streaming) |
| Voice deepfake detection | — No equivalent | Bonafide or Spoofed, batch and streaming |
| Face, text and vocal-burst models | Yes | — No equivalent |
| Speech generation (EVI LLM and TTS) | Separate Hume products (ending 13 Nov 2026) | — No equivalent |
| Batch API | REST batch jobs | v5 REST API or Python SDK |
| Live audio | WebSocket | gRPC streaming, 16-bit linear PCM |
| Deployment | Cloud | Cloud, customer-hosted or edge |
— No equivalent: the capability has no match on that side. Partial: a related output exists but works differently.
*Hume’s new Expression Measurement API (limited release, 6 October 2026) wasn’t evaluated here.
One API. Different ways to make AI more human-aware.
AI agents
Give agents context that words alone do not carry. Pass per-utterance emotion, strength, positivity, stress, confidence and hesitation into the agent’s prompt or routing logic, and let the agent decide how to respond.
Customer experience
Analyze recorded calls in batch with transcript, speakers and expressed emotion together, or stream live calls for emotional and behavioral signals as they happen.
Healthcare applications
Add vocal behavioral context to human-centered conversational experiences. The API returns estimates of expressed signals, not a diagnosis or a clinical assessment.
Automotive
Help in-vehicle systems respond to how people speak. The same models run at the edge.
Robotics and HMI
Give machines another layer of information about human communication, from a stream of live audio, in customer-hosted or edge deployments.
Trust & security
Combine behavioral signals with voice deepfake detection where a workflow needs to understand the speaker and check whether the voice is synthetic. The two results stay independent.
Also in the API
Understand the speaker. Check the voice.
Behavioral Signals also detects synthetic speech. Voice deepfake detection returns Bonafide or Spoofed, with probabilities, and is speaker-agnostic. It runs through its own endpoint, in batch and in streaming, independent of the emotional and behavioral outputs.
97.9% average Macro-F1 for speaker-agnostic deepfake detection on our internal multi-domain evaluation set. Validate on your own audio before launch.
Runs on the same streaming connection pattern as emotion (DeepfakeDetection rpc).
Questions developers ask before they migrate
Is Behavioral Signals an alternative to Hume AI?
For speech analysis, yes. Behavioral Signals is a drop-in replacement for the Hume API. If you used Hume Expression Measurement to analyze recorded or live speech, most often through the Speech Prosody model, the Behavioral Signals API covers that part of the workload: per-utterance estimates of expressed emotion, strength, positivity, stress, confidence, hesitation and speaking rate, with transcription, diarization, language and speaker attributes. It does not cover vocal bursts, text, facial expression or named-entity models, or Hume’s Empathic Voice Interface.
Can I migrate from Hume Expression Measurement to Behavioral Signals?
Yes. The request and response changes are mechanical. The work that needs care is any rule your product applies to a Hume score, such as a threshold on Distress. Those rules are re-expressed over Behavioral Signals classes and re-fitted on your own audio. The Hume Migration Guide walks through each step.
What does a developer need to change?
Four things. The client and credentials: an API key in the X-Auth-Token header and a client ID in the path, or the Python SDK. The request: one recording per process, then poll for results. The parsing: group the flat results by utterance and cast values, which arrive as strings. The rules: map the Hume dimensions you use and re-fit their thresholds. Live paths also move from WebSocket to gRPC with 16-bit linear PCM.
How do Behavioral Signals outputs map to Hume’s expression measures?
By meaning, not one to one. Hume returned 48 prosody dimensions; Behavioral Signals returns four emotion classes, three levels each of strength and positivity, and separate behavioral outputs. Anger, Sadness and Joy map to a class of the same meaning. Most other dimensions are approximated from one or more outputs. Some, such as Nostalgia or Determination, have no direct equivalent. The Migration Guide maps every dimension and explains your options for the gaps.
Do I need to replace my LLM, AI agent or voice platform?
No. Behavioral Signals is an analysis API. Your LLM, agent, voice platform and application logic stay in place and read the signals from the API response.
Can I use Behavioral Signals alongside Hume?
Yes. Behavioral Signals is a separate API with its own credentials, so it can run next to any Hume product you keep. If you stored Hume Expression Measurement outputs, you can run the same recordings through Behavioral Signals and compare.
What emotion and behavioral signals does Behavioral Signals provide?
Emotion (happy, angry, neutral, sad), strength (weak, neutral, strong), positivity (negative, neutral, positive), hesitation (no, yes), engagement (engaged, neutral, withdrawn) and speaking rate (slow, normal, fast), stress and confidence, plus a continuous intensity score. Speaker diarization and ASR are included at no extra charge. Batch also returns the detected language. Estimated age band and gender are returned per speaker in batch and per segment in streaming. Voice deepfake detection runs through its own endpoint. Every classified output carries a probability for each class.
How does Behavioral Signals differ from Hume’s legacy Expression Measurement API?
Hume returned an independent score for each of 48 dimensions. Behavioral Signals returns a probability distribution over a smaller set of classes per task, plus a final label, so you set the threshold at which your application acts. For emotion and behavior, Behavioral Signals is voice-only and analyzes utterances rather than individual words. It adds estimated age band and gender, and deepfake detection for voice (and, experimentally, video).
Does this cover Hume’s new Expression APIs?
No. This page is for teams moving off Hume’s legacy Expression Measurement API. If you are comparing options, run the same recordings through your free batch minutes and compare the results yourself.
Does Behavioral Signals support real-time streaming?
Yes. The streaming API runs over gRPC and takes 16-bit linear PCM, mono; 16 kHz gives the best results. It returns emotional, behavioral and speaker outputs for fixed two-second segments, for complete utterances, or both.
What latency should I expect?
Streaming returns results while the conversation is running; batch returns results after the file is processed. Measure latency on your own deployment before you commit to a latency budget.
Can Behavioral Signals analyze recorded audio?
Yes. Batch processing takes recorded audio, one recording per process, by file upload or S3 signed URL, and returns the full set of outputs, including transcript, speakers and language.
Can I test Behavioral Signals before migrating, or before talking to sales?
Yes. The API is self-serve: create an account, verify your email, issue a key, and send your first recording. New accounts include 30 free minutes of behavioral batch processing, with no credit card required. Developer documentation includes a live console on every endpoint.
What does it cost after the free minutes?
You pay per minute from one prepaid balance. Behavioral: $0.10 per minute batch, $0.15 per minute streaming. Deepfake audio: $0.25 per minute batch, $0.50 per minute streaming. Deepfake video (experimental): $0.50 per minute, batch. See pricing.
Can I use the same audio I previously used with Hume?
Yes, you can send the same recordings. Two differences: Hume batch jobs could take a list of URLs, while Behavioral Signals takes one recording per process, by upload or S3 signed URL. Live audio is sent as 16-bit linear PCM. Batch accepts wav, mp3 and other non-proprietary audio formats. Minimum utterance length varies by task; see the docs.
Does Behavioral Signals provide voice deepfake detection?
Yes. Speaker-agnostic voice deepfake detection returns Bonafide or Spoofed, through its own endpoint, in batch and streaming. It reached 97.9% average Macro-F1 on our internal multi-domain evaluation set. It is a detection result about the audio, independent of the emotional outputs, and not a verdict about a person.
What deployment options are available?
The same models run as a cloud API, in customer-hosted deployments and in edge implementations, in batch and streaming. Self-serve sign-up starts you on the cloud API. For customer-hosted or edge deployment, talk to us.
What languages are supported?
We currently support 11 languages: English, Arabic, Russian, Chinese, French, German, Spanish, Portuguese, Japanese, Hindi, and Tamil. Our approach is language-agnostic by design. It doesn’t use a separate model for each language, and it doesn’t need to understand the words being spoken.
Keep your stack. Add Behavioral Intelligence.
Hume EVI and TTS end 13 November 2026.
Run your own recordings through the API, apply the mapping, and decide on evidence from your audio, not ours.
Self-serve sign-up. New accounts include 30 free minutes of behavioral batch processing, with no credit card required.
Need help mapping your Hume implementation? Talk to us →
Hume, Expression Measurement and Expression APIs are named for identification only. Information about Hume Expression Measurement is based on Hume’s public SDK schema and release notes. All Behavioral Signals outputs are probabilistic estimates of signals expressed in speech, not determinations of what a person feels, intends or believes.
Developer documentation Python SDK API White Paper Integrators’ Discord