The ai interview api lets you embed a structured AI interviewer in your own product: it runs the conversation in a browser or over the phone, transcribes and analyzes each answer, and returns scored, structured JSON from a single REST call.
{
"interview_id": "iv_4af20c",
"channel": "phone",
"overall_score": 82,
"competencies": {
"communication": 88,
"problem_solving": 79,
"customer_focus": 84
},
"language": { "cefr": "B2", "fluency": 86 },
"fraud_signals": {
"multiple_speakers": false,
"reading_detected": false
},
"status": "completed"
}Anything that needs a candidate to talk and a score to come back. You own the questions, the channel, and the UI; the API handles the conversation, the transcription, and the interview analysis, and hands you JSON.
Because the AI interview api is context-agnostic, the same endpoint powers a careers-page screener, an outbound phone round, or an interviewer embedded inside another vendor's ATS. The same scoring engine also powers ZenHire's own structured ai interview solution, so you are building on a proven evaluation pipeline rather than a thin LLM wrapper. The edge case to plan for is a silent or near-silent recording: when there is too little speech to score, the call returns a low-confidence flag rather than a fabricated number, and a failed run is never charged: the platform checks your credit balance before processing and bills only work that completes.
Consistency is the point of automating the interview: ZenHire's spoken-English scoring aligns 90-96% with a panel of 5 PhD linguists, while untrained human recruiters land at only 68-75% on the same audio. One endpoint gives every candidate the same calibrated read.
You create an interview from a reusable interviewer persona, a role plus a language you define once, with your question set and a channel; the candidate joins on the web or answers a call; the API conducts the conversation over bidirectional audio streaming with sub-second AI response latency, records audio, and processes each response. One conversational interview api drives both surfaces, so you do not maintain two pipelines, and every session stays per-candidate.
On a two-way call, speaker diarization separates the interviewer from the candidate and scores the candidate only, and candidate-only audio extraction keeps the read clean in a noisy room. The same spoken-language signals are documented in detail on the speech analysis api, since both share one audio-scoring core. Where a phone line drops mid-answer, the API scores what completed and marks the response partial, so a bad connection never silently inflates or sinks a candidate. And an interview that ends without a result can be re-invited with a fresh link, so one dropped call never costs anyone the round.
1. Create the interview
POST your question set and channel (browser or phone) to /v1/interviews and get an interview ID and join link. The link carries its access token in the URL fragment, never sent to a server, so the candidate's entry point stays private.
2. Candidate responds
They answer in the browser or over the phone; the API conducts the conversation and records each response in roughly a 4-minute interview.
3. Transcribe and analyze
Audio is transcribed, diarized to the candidate, and analyzed for competency and language signals.
4. Read the scores
Poll or receive a webhook, then parse the JSON: overall score, per-competency scores, language read, and fraud signals. Run ids never expire, and an externalId plus up to 50 metadata keys and 20 tags per run keep every result filterable from your ATS.
Each completed interview resolves to a structured verdict, not a recording to review. You get an overall score, weighted per-competency scores, a CEFR language level, and a fraud-signals object, all keyed and ready to route on. Pair it with the candidate scoring api when you want one ranked shortlist that folds interview results in with the rest of your funnel.
Some teams assume an automated interview api is an opaque box that spits out a number. It is the opposite here: the architecture is glass-box and explainable, sensitive attributes such as race, gender, and age are excluded from inputs by design to reduce bias in hiring, and per-dimension explanations ship with the score so a recruiter can audit any call and override it. The integrity layer that powers this maps directly to ZenHire's anti-fraud assessment integrity tooling, so the same checks you trust on the platform run on every API call.
The score is meant to stand up to scrutiny, not just save time: when ZenHire's AI ranking is sorted against blind human review, the top and bottom deciles agree 93%+ of the time with human screeners: close enough to trust the shortlist, transparent enough to audit any call.
| Field | What it carries |
|---|---|
| overall_score | 0-100 weighted result across your scored competencies |
| competencies | Per-competency scores for the framework you defined |
| language | CEFR level (A1-C2) plus a fluency read from the spoken answers |
| fraud_signals | Multiple-speaker and reading/scripted-response detection per call |
| transcript | Diarized JSON transcript of the candidate's answers, optional in the response |
| recording | Full session audio delivered as audio/wav, kept alongside the transcript for audit |
| status | Completed, partial, or low-confidence so you never rank on noise |
The AI interview API is a REST endpoint that runs a structured interview for you and returns scored JSON. You supply the questions and the channel; it conducts the conversation in a browser or over the phone, transcribes and analyzes each answer, and hands back an overall score, per-competency scores, a CEFR language read, and fraud signals.
The AI interview API runs interviews over the phone as well as in a browser, from the same endpoint. On a two-way call it diarizes the audio to isolate the candidate and extracts candidate-only audio for a clean read, so hourly and field applicants who never open a laptop still get a consistent, scored interview.
This is a conversational interview api, not a transcription service. It conducts the interview, then scores the responses against the competency framework you define and returns weighted results, a language level, and fraud checks. The transcript is an optional field, not the product, so you receive a decision-ready verdict rather than text to grade by hand.
The automated interview api runs integrity checks on every call: multiple-speaker detection catches proxy interviews, reading detection flags scripted or AI-generated answers, and diarization confirms the candidate is the one speaking. Scripted-response detection runs around 91% accuracy, and any flag routes the response to a manual review queue.
The AI interview API is built to be fair and explainable. Sensitive attributes such as race, gender, ethnicity, and age are architecturally excluded from inputs and models, the scoring is glass-box and deterministic rather than a black box, and per-dimension explanations ship with each result, aligning with GDPR's right to explanation. It is also SOC 2 Type II certified.
Yes. The endpoint is context-agnostic and white-label-ready, so you can drop a structured interviewer into a product you already sell over one REST call. If you are wiring it into an existing tracking system, the recruitment api for ats covers how scores and shortlists flow back into your pipeline.
Free for AI Interview API integration
A developer-ready spec sheet: the /v1/interviews request and response schema, the fraud_signals and CEFR fields explained, webhook setup, and how to map scores back into your pipeline.
Run browser and phone interviews over one REST endpoint, and read back scored JSON instead of recordings.