Skip to content
ConsultEvo

BrightHire Zapier Integration: Supported Workflows and Safe Design

The BrightHire Zapier integration currently lists an instant New Completed Interview trigger, Find Interview and Find Scheduled Interview searches, candidate, position, and scheduled-interview creation actions, deletion actions, and API Request (Beta). This makes it useful for connecting recruiting records and interview follow-up, but it does not by itself define your validation, duplicate prevention, approvals, or exception ownership.

This guide focuses on workflow design rather than a field-by-field setup tutorial. You need a BrightHire account and an API key to connect. Zapier says an administrator can generate the key under BrightHire Settings and REST API. Available fields and conditional requirements can vary, so verify them in the live Zap editor before building a production workflow.

Review BrightHire’s currently listed Zapier capabilities and see Zapier’s BrightHire connection guide for the current connection prerequisite.

What the BrightHire Zapier integration can do

Zapier currently lists these BrightHire capabilities:

  • Trigger: New Completed Interview, labeled instant.
  • Searches: Find Interview and Find Scheduled Interview.
  • Create actions: Create Candidate, Create Position, and Create Scheduled Interview.
  • Deletion actions: Delete Candidate, Delete Interview, and Delete Scheduled Interview.
  • Custom boundary: API Request (Beta), with controls for method, URL, query parameters, headers, body, and stopping on error.

Find Interview requires a BrightHire interview ID and can return material such as transcripts, recordings, notes, questions, and talk-time analytics. Find Scheduled Interview uses a scheduled interview ID and returns details such as candidate, position, guide, and interviewers. The public integration page does not publish BrightHire endpoint paths or request schemas for custom requests.

A form, spreadsheet, ATS, scheduling system, or calendar can start a workflow only when that other app is connected and supplies the required data. Those are not native BrightHire triggers. Likewise, Slack messages, tasks, documents, and AI processing are downstream steps in separately connected apps, not BrightHire actions.

Zapier publicly shows a Google Sheets-to-BrightHire candidate example. Treat it as a starting pattern, not a complete implementation: the public page does not establish its full mappings, validation, duplicate controls, approvals, or exception handling.

Make the source event, record grain, destination, and exception owner explicit before adding automation.

Choose the record grain before mapping fields

Record grain means what one record represents. Keep one record per candidate, position, scheduled interview, and completed interview. A candidate can have several interviews, so interview-specific notes should not be stored as though they were one candidate-level fact. If you create a candidate summary, make it a separate aggregate that references the underlying interview IDs.

Use the corresponding stable source identifier at each grain: candidate ATS ID for a candidate, position ATS ID for a position, and interview ATS ID for a scheduled or completed interview. Confirm that each identifier belongs to the intended entity and ATS environment before mapping it to a BrightHire action.

For candidate creation, require a candidate ATS ID and normalize email as a secondary matching aid. Do not replace a stable ID with email. A proposed key such as (source_system, candidate_ats_id) is an implementation recommendation, not a BrightHire schema. When concurrent runs are possible, enforce that key with a durable database uniqueness constraint and a transactional upsert. A search followed by Create Candidate can still race.

Apply the same principle to positions and interviews. Use (source_system, position_ats_id) for position creation and (source_system, interview_ats_id) for scheduled-interview creation. For a notification, include the destination and notification type in the key, such as (brighthire_interview_id, destination, notification_type). These proposed keys identify different row grains and should not be mixed.

Build deterministic workflow patterns

The patterns below are proposed designs that use documented BrightHire actions. Their upstream events, field mappings, control stores, and exception queues depend on the other connected applications and your operating environment.

Trigger and chain Data or AI job Validation Action and fallback
Form, ATS event, or sheet row -> validate -> Create Candidate Candidate ATS ID, name, email, and applicable profile or ATS URL. No AI required. Confirm candidate grain, normalize email, and enforce (source_system, candidate_ats_id) outside the Zap when runs can overlap. Create the BrightHire candidate. Queue missing IDs or ambiguous matches for recruiting operations.
Approved requisition event -> validate -> Create Position Position ATS ID, title, department identifiers, status, requisition ID, locations, and applicable ATS URL. Confirm the source ID identifies a position or requisition, and that department ID and name agree. Create the BrightHire position. Route conflicting department data or permission failures to the ATS or integration administrator.
Scheduling or ATS event -> normalize times -> Create Scheduled Interview Interview, candidate, interviewer, and position IDs, name, location, start and end times, and applicable guide or stage fields. Require the source interview ID, normalize timezone, verify end follows start, and deduplicate by source interview ID. Create the scheduled interview. Send missing guide, stage, or identity data to a recruiting coordinator instead of creating a partial record.
New Completed Interview -> optionally Find Interview -> destination app Interview context, controlled link, or approved summary. AI may draft text but does not authorize the notification. Verify interview, candidate, and position identity; check transcript availability when required; use a processed-event key for duplicate-sensitive notifications. Send only approved fields to Slack, email, task, or document tools. Route missing data or delivery failures to recruiting operations or the destination owner.

For a scheduled interview, an illustrative input might include interview_ats_id, candidate_ats_id, interviewer_ats_id, position_ats_id, start_time, and end_time. Map these to the corresponding fields available in the live editor, along with any applicable name, location, guide, stage, ATS URL, or Force recording field. Do not use candidate plus date as the uniqueness key because one candidate can have multiple interviews on the same day.

For a completed interview, begin with New Completed Interview. If the trigger does not include the details needed downstream, pass its interview ID to Find Interview. A missing ID, unexpected candidate or position, or absent transcript should stop the normal route and enter an assigned exception path. Do not silently continue with a guessed match.

01Receive the source eventCapture the upstream record or completed-interview event, its source ID, and the source-system name. The source application owner is responsible for a usable event.
02Validate identity and required dataCheck record grain, source IDs, allowed values, timestamps, and required interview material. Route failures to the named recruiting operations owner.
03Create or retrieve the BrightHire recordUse the documented action that matches the intended record, or Find Interview when the completed-event payload is insufficient. Store the returned BrightHire ID beside the source ID.
04Route success or exceptionSend only approved fields to the destination app. Record the run and destination reference, and assign unresolved exceptions to a person rather than leaving them in a failed-run list.

Use AI for interview synthesis, not workflow authority

Keep completion checks, identity matching, transcript presence, stage routing, and permission to write data deterministic. AI can draft interview themes, concerns, open questions, or interviewer preparation notes from retrieved material. It should not decide whether an interview is complete, change hiring status, authorize deletion, or make a consequential hiring judgment.

A proposed output contract for a preparation draft could look like this:

{
  "interview_id": "bh_int_9903",
  "candidate_ats_id": "cand_4821",
  "position_ats_id": "pos_203",
  "summary": "Draft for review",
  "strengths": [],
  "concerns": [],
  "open_questions": [],
  "evidence": [],
  "model_provider": "record-at-runtime",
  "prompt_version": "prep-v1",
  "generated_at": "2026-11-20T15:00:00Z",
  "human_review_status": "pending"
}

This is an illustrative contract, not a BrightHire or Zapier schema. Validate that the output parses, that fields use allowed values, and that its interview, candidate, and position IDs match the retrieved source. Keep observations at interview grain, preserve source references, and record the model or provider, prompt version, and generation time. A named recruiter or interviewer should review the draft before it is shared or written back.

Zapier’s article dated June 17, 2026 reports a Talent-team pattern connecting Ashby, BrightHire, Google Docs, and Slack to prepare materials for a final-stage interview. It does not publish a reproducible configuration, exact trigger, prompts, permissions, validation, or approval process. Current Zapier documentation says Agents are moving to AI by Zapier, so names and interfaces may differ. Teams designing bounded assistance can also review AI agent services.

Decision point

Let AI draft open questions from cited interview evidence. Let deterministic rules establish that the right interview is complete, correctly matched, and permitted to proceed, with human approval before distribution or write-back.

Transcripts, recordings, notes, and derived summaries are sensitive recruiting data. Minimize what goes to downstream tools, prefer access-controlled links over full transcript copies in broad Slack channels, and confirm organizational policy before sending interview content to an AI provider. Review permissions separately in BrightHire, the ATS, Zapier, the destination app, and any AI provider.

Treat API Request (Beta) as a verified boundary

Use a documented BrightHire action when it covers the requirement. Consider API Request (Beta) only after verifying the exact endpoint, method, authentication, payload, response, and error behavior against current BrightHire documentation or the live editor. Zapier’s general documentation describes API Request as a raw HTTP action using the app connection for authentication, but the public BrightHire integration page does not publish BrightHire endpoint paths or schemas.

Do not infer an undocumented operation from the presence of the action. Test whether the operation is destructive, validate the response fields required by the next step, and record the test date because the action is beta. For Delete Candidate, Delete Interview, and Delete Scheduled Interview, define authorization and retention rules and add safeguards against accidental removal before enabling the action.

Operational checks before launch

Retries and replays can recover qualifying failed runs, but they are not idempotency. A replayed create or notification can duplicate a successful external write. For duplicate-sensitive notifications, use a durable processed-event key such as (brighthire_interview_id, destination, notification_type). For concurrent writes, use a database uniqueness constraint and transactional upsert rather than relying only on a lookup step. Zapier’s general documentation covers replay, duplicate data, and troubleshooting. These are general workflow references, not guarantees about BrightHire-specific behavior.

Use filters or paths for explicit outcomes: stop when an interview ID is missing, send a transcript-missing case to a recruiter, and send an identity mismatch to an exception queue. Keep the business rules visible and assign each unresolved case to a person.

Review before rollout
  • Candidate, position, scheduled-interview, and notification writes use stable keys at their declared grain.
  • A concurrent run and a replay cannot create a duplicate record or notification without detection.
  • Transcript destinations are restricted, and organizational policy approves any AI-provider use.
  • A named owner handles missing IDs, identity mismatches, absent transcripts, invalid AI output, and failed destination writes.
  • A replay test confirms that retrying a failed run does not duplicate a previously successful write.

Measure outcomes operators can observe: duplicate records, failed runs, missing-field exceptions, and time from completion event to reviewed follow-up. Teams translating documented app actions into governed workflows can learn more about Zapier automation services.