If you run hiring on Greenhouse, you have already made a sensible operational choice. Greenhouse's stage-based workflows, scorecard model, and Harvest API give recruiting ops a level of control that most ATS competitors do not. The question is how to layer a structured AI-assisted interview on top of that workflow without breaking what already works.

This playbook covers the integration patterns that hold up under load, the data hand-offs that matter, and the failure modes worth pre-empting.

The right integration goal is not "replace recruiter judgement." It is "give the recruiter a complete, evidence-backed scorecard before they spend a minute on a phone screen."

The Greenhouse data model, in the only depth you need

Three Greenhouse objects matter for an AI interview integration:

Candidate — the person.
Application — the candidate's application to a specific job. A candidate can have multiple applications.
Scorecard — the structured evaluation tied to a specific interview stage on an application.

The integration revolves around the application. The AI interview platform receives a candidate's resume and the job context, runs the interview, and writes a scorecard back against a defined interview stage.

The Harvest API is Greenhouse's main read/write API. The Job Board API is read-only and surfaces public job data. Webhooks notify the integration of stage transitions and application events. A well-built integration uses all three.

The four integration patterns, ranked by maturity

Pattern 1 — Email handoff

The lowest-effort integration. The recruiter manually invites the candidate via the AI interview platform; the platform emails a PDF scorecard back which the recruiter attaches to the Greenhouse application.

This works, technically. It also defeats most of the point. The Greenhouse scorecard system stays empty. The audit trail is fragmented across email and PDF. Cross-application analytics are impossible.

Acceptable for a pilot. Not acceptable as a steady state.

Pattern 2 — Stage-triggered API write

The first real integration. A Greenhouse webhook fires when a candidate enters a designated interview stage (commonly "AI Screen" or "Structured Phone Screen"). The integration receives the webhook, invites the candidate, runs the interview, and writes the result back via Harvest API as a Greenhouse scorecard against the stage.

This is the pattern that most mid-market customers should target. It keeps the system of record clean. Recruiters see the AI scorecard in the same place they see every other scorecard. Greenhouse's existing approval workflows and reporting all continue to work.

The hand-off needs three specific data fields on the way in: the job ID, the application ID, and the candidate's contact details. On the way out: the scorecard fields mapped to the Greenhouse rubric for that stage.

Pattern 3 — Bidirectional sync with custom fields

A more sophisticated pattern. Custom fields on the Greenhouse candidate or application object hold AI-specific metadata — interview link, status, completion timestamp, link to the full transcript. The integration writes both the standard scorecard and these custom fields, and a recruiter can move the application forward without ever leaving Greenhouse.

This is the right pattern for any company doing more than 200 interviews per month. The extra setup pays back quickly in recruiter time saved.

Pattern 4 — Embedded experience

The most invested integration. The AI interview is launched directly from the Greenhouse candidate profile via a Greenhouse integration. The transcript and scorecard render inline.

This is overkill for most teams. It is the right answer for enterprise customers running hundreds of interviews per week where any context-switching cost compounds.

The seven hand-off fields that matter most

Whichever pattern you adopt, the integration's quality depends on getting seven hand-offs right.

Job context. The AI needs the job title, the role description, and ideally the success profile that the recruiter is hiring against. Without this, the interview questions revert to generic competency probes.
Stage definition. Which Greenhouse interview stage does this AI screen replace or supplement? The scorecard must map to the rubric defined for that stage.
Candidate consent state. Is the candidate already aware that an AI interview is part of the process? If not, the platform must capture consent at session start.
Resume. Used by the AI to personalise opening questions and to skip basic eligibility checks the resume already answers.
Locale and language preference. A candidate applying to a Dubai role from Cairo may prefer Arabic; a Bangalore candidate may prefer English. The integration should pass this through.
Scorecard schema. The Greenhouse scorecard for the stage defines the competencies, the scale, and the required free-text fields. The AI output must conform to this exactly.
Failure escalation channel. If the AI interview fails — candidate drop-off, technical error, audio quality issue — the integration must surface the failure to a named recruiter via a defined channel, not silently leave the application in limbo.

The state machine that actually works

A robust integration treats the AI interview as a state machine attached to the Greenhouse application. The minimum states:

invited — the candidate has been emailed an interview link.
started — the candidate has opened the link and consented.
in_progress — the interview is underway.
completed — the interview is finished and the scorecard is being generated.
scorecard_written — the scorecard has been successfully written to Greenhouse.
failed — something went wrong; recruiter intervention required.
expired — the candidate did not start within the invite window.

Every state transition writes to a custom field on the Greenhouse application. Recruiters can filter on this in their candidate views. Operations can pull this for funnel analytics.

The states the integration must surface as visible to recruiters are invited, failed, and expired. The others can stay in the background.

Three failure modes to pre-empt

Failure mode 1 — Scorecard schema drift

Greenhouse customers customise their scorecard rubrics. If a recruiting ops admin adds a competency to the "AI Screen" stage and the integration is not aware, the scorecard write fails. The defensive design is to read the scorecard schema from Greenhouse at the start of every interview, not at integration setup time, and to either map dynamically or fail loudly with a recruiter-facing error.

Failure mode 2 — Webhook delivery gaps

Greenhouse webhooks are at-least-once. Occasionally, they are at-zero-once. A production integration cannot rely solely on webhooks for stage-transition events. It should also poll the Harvest API for applications in the trigger stage on a defined interval (commonly every 15 minutes) and reconcile.

Failure mode 3 — Candidate identity collisions

A candidate may have multiple applications across multiple jobs. The integration must scope the interview to the specific application, not to the candidate. Writing a scorecard against the wrong application is a hard recovery; surfacing it via an inline confirmation step is much cheaper.

What the recruiter actually sees

The day-to-day experience for a Greenhouse-using recruiter after the integration is live should look like this:

Recruiter moves a candidate into the "AI Screen" stage.
Within minutes, the candidate receives a branded invite email.
The candidate completes the interview at their own time, on desktop or mobile.
Within a few minutes of completion, the Greenhouse application shows a new scorecard with structured competency scores and evidence quotes.
Recruiter reviews the scorecard, decides whether to advance, and either moves the application to the next stage or rejects with a defensible written rationale.

What the recruiter does not see: a separate dashboard to check, a separate login to manage, or a PDF attachment to download. The Greenhouse interface is enough.

A 30-day rollout sequence that holds up

For a mid-market team adopting AI-assisted interviews on Greenhouse, the lowest-risk sequence is:

Week 1. Pick one role with steady, high volume. Define the AI Screen stage in Greenhouse. Document the scorecard rubric.
Week 2. Run the integration in pattern 2 — webhook trigger, API scorecard write. Pilot on 20 candidates, manually reviewing each scorecard.
Week 3. Compare AI scorecards to the recruiter's independent first-round notes. Calibrate the rubric where they diverge.
Week 4. Expand to the rest of the team for that role family. Add the custom fields needed for pattern 3.

The mistake to avoid is rolling out across all roles in week 1. Calibration is role-specific; trust is built one role at a time.

Where this leaves you

A clean Greenhouse + AI interview integration produces three durable wins: recruiters spend less time on first-round screens, every candidate is assessed against the same rubric, and the audit trail lives where it belongs — inside the ATS that is already the system of record.

To see what the candidate side of that flow actually looks like, the Voxxhire demo walks through a complete interview and scorecard in under three minutes.

For the same playbook against a different ATS stack, see our piece on Zoho Recruit and Keka for India hiring. For a deeper look at how voice-first interviews produce richer signal than one-way video, see why voice-first interviews outperform one-way video.

For an example of a structured AI hiring rollout at an early-stage company, see the Exara AI design partner case study.

Greenhouse + AI Interview Integration: A Practical Playbook