Skip to content
Get a quote

Migrate to Bullhorn ATS & CRM

Bullhorn is a staffing-industry ATS whose import model rewards teams that pre-create custom fields, respect the Custom Import 100-record pagination quirk, and load entities in the strict Candidate → JobOrder → JobSubmission → Placement order.

Short answer

FlitStack AI migrates employees, payroll, and benefits into Bullhorn ATS & CRM from 200+ HR systems, including Crelate, Greenhouse, Rippling, BambooHR. Every field is mapped to Bullhorn ATS & CRM's objects, history and associations come across, the Bullhorn ATS & CRM setup is configured alongside, and the whole migration stays reversible in one click.

By

From Any source
DestinationBullhorn ATS & CRM
CrelateGreenhouseRipplingBambooHR
200+ sources mapped into Bullhorn ATS & CRM

Systems we move into Bullhorn ATS & CRM

The HR systems teams most often move from. Each page shows what moves, the field mapping and what to watch for.

What Bullhorn ATS & CRM supports, and where its import tools stop

  • Agencies choose Bullhorn because it combines ATS and CRM in one platform, eliminating the need to switch between separate tools for candidate management and client relationship tracking.
  • The resume parser extracts contact details, work history, and skills into structured, searchable candidate profiles automatically without manual data entry, reportedly driving 24% more placements per recruiter.
  • Bullhorn's placement and split-billing model natively supports contract staffing workflows, handling start/end dates, overtime rules, and multi-party pay/charge rates in a single record.
  • The platform offers extensive third-party integrations through its Recruitment Cloud Marketplace, connecting with back-office, onboarding, and payroll systems used by staffing agencies.
REST onlyOAuth 2.0
Rate limits1,500 req/min, 100,000 calls/month, 50 concurrent sessions, 50 subscriptions; ATS Growth edition has NO API access
ObjectSupportNote
CandidatesfullBullhorn's primary ATS record storing parsed resume data, work history, skills, and status. Candidates have rich custom fields and associations to JobOrders via CandidateList entities. We migrate Candidates 1:1 including all standard fields, custom properties, and the CandidateJobManager associations. Original resume files require separate file-reference queries.
JobOrders (Jobs)fullJobOrder is Bullhorn's job record containing requirements, status, location, and salary information. Jobs link to Clients and track assignments through Bullhorn's pipeline stages. We map JobOrder records including all standard fields, custom properties, and job-client associations. Job board posting configurations are environment-specific and typically require manual recreation at the destination.
ClientsfullClient (also called ClientCorporation) is Bullhorn's CRM company record representing the staffing agency's customer. It stores company details and primary contact. We migrate all Client fields and the client-contact association. Client-specific custom fields should be reviewed for naming conflicts at the destination.
ContactsmappedBullhorn Contacts represent both client-side business contacts and candidate references. They share a schema but serve different roles. We separate Contacts by their entity type during migration to avoid conflating client contacts with candidate-related contacts, and preserve type metadata as a custom field at the destination.
OpportunitiesmappedBullhorn Opportunities are CRM-level pipeline deals tied to Clients, representing sales pipeline stages distinct from the ATS submission flow. They map to standard CRM opportunity objects. Recruitment-specific opportunity stages (Interview, Offer, etc.) require field-level mapping to match the destination's pipeline terminology.
PlacementsfullPlacement is Bullhorn's transactional record representing a hire, linking Candidate, JobOrder, and Client, with billing information including pay and charge rates. Contract placements carry overtime rules and start/end dates critical to billing accuracy. We preserve all placement fields including contract terms and billing details, which most destination systems store as placement or hire records.
TasksfullBullhorn Tasks store to-dos with type, due date, status, and owner assignment across entities. They map cleanly to standard CRM task objects. ATS Growth edition caps API subscriptions at 50, which may require phased migration for active task lists.
Custom ObjectsmappedBullhorn Custom Objects extend core entities with module-like data (up to 55 fields each). ATS editions are limited to 2 searchable custom objects, while Front Office Growth/Enterprise allow 10. We migrate custom object records and field definitions, but destination systems may require schema redesign due to object-count limits and naming differences.
AttachmentsmappedBullhorn stores resume files, parsed documents, and communications as separate attachment objects. We migrate attachments via Bullhorn's file reference URLs. Bullhorn's standard CSV export does not include attachments—only the API preserves them. We explicitly include attachment migration in the scope to avoid silent data loss.
CandidateLists (Job Submissions)mappedCandidateList represents a candidate's submission to a specific job, storing status within the recruitment pipeline. CandidateLists map to destination submission or application records and carry the Candidate-to-JobOrder association. We preserve the full association chain including submission status.
Users (Owners/Recruiters)fullBullhorn Users are system accounts representing recruiters, sales staff, and administrators with assigned roles and permissions. User records include name, email, role, and department. We migrate Users 1:1 and map ownership references across all owned entities to maintain audit trails.

The Bullhorn ATS & CRM migration guide

Why teams migrate to Bullhorn

The four shapes a Bullhorn migration takes, and what makes the platform easier — or harder — than the category average.

Bullhorn, Inc. is an American cloud company headquartered in Boston, with operations in St. Louis, London, Brighton, Sydney and Rotterdam1. The platform provides applicant tracking, CRM and operations software for the staffing industry, and more than 10,000 firms run their recruitment workflows on it12.

The typical Bullhorn customer is a staffing or recruitment agency — five to several hundred recruiters — managing candidates, client contacts, job orders and placements in one connected workflow. Compared with generalist ATS products like Greenhouse, Bullhorn positions on staffing-industry depth: Sendouts, Tearsheets, VMS Sync and a marketplace of 300+ pre-integrated partners12. Compared with JobAdder or Crelate, it positions on platform maturity and a richer toolset for staffing workflows.

The shapes of migration that actually land on Bullhorn tend to fall into four patterns. First, homegrown-ATS replacements: an agency moving off a spreadsheet, an Access database or a bespoke in-house tool with limited outreach capabilities. Second, vertical-ATS swaps, where the source is Crelate, JobAdder, PCRecruiter or Avionté and object parity is reasonable but custom-Category structures are not.

Third, generalist-ATS exits — Greenhouse, Workable, Lever — where the source pipeline-per-job model has to be re-shaped into Bullhorn's Candidate → JobSubmission → Placement chain. Fourth, M&A consolidation, where an acquired agency runs on a different ATS. A Crelate migration usually has clean entity parity but messy custom-Category labels; a Greenhouse migration has rich scorecards that do not move natively.

What makes migrating to Bullhorn easier than the category average is the Bullhorn Data Loader — an open-source Java tool maintained by Bullhorn that ingests CSV for nearly every entity and upserts by externalID3.

What makes it harder than the average is the entity ordering constraint — Candidates must exist before JobSubmissions, JobOrders before JobSubmissions, ClientContacts before Notes — and the Custom Import quirk where clicking Next more than once on the preview screen silently duplicates records142. Resume Parser settings, EEOC fields and JobSubmission status histories all need explicit decisions up front.

Reports built in Bullhorn Reporting (formerly Canvas), Pulse activity rules and Bullhorn Automation journeys do not import — they are rebuilt from documentation. Teams that scope for that work finish on time; teams that assume parity do not.

Teams that scope for the rebuild work up front finish on time; teams that assume parity do not.

The Bullhorn data model you need to map into

Entities, custom fields, associations, and the externalID upsert key you'll wire on every load — the destination schema decoded.

Bullhorn's ATS is built around a small set of staffing-specific entities, each with default and custom fields, and associations that connect them.

Before you can map a field on the source side, you need to know which destination entity the row belongs on, which fields it requires, and which value will serve as its upsert key. The table below summarises the entities you will touch.

ObjectWhat it storesRequiredTier
CandidatePeople you place — applicants, contractors, perm hiresfirstName, lastName, statusAll editions
ClientContactHiring-manager-side individuals at client companiesfirstName, lastName, clientCorporation, statusAll editions
ClientCorporationClient companies you place candidates withname, statusAll editions
Lead / OpportunityPre-conversion sales records (CRM side)name, status, ownerBullhorn CRM / Front Office tiers
JobOrderOpen requisitions from clientstitle, clientCorporation, clientContact, statusAll editions
JobSubmissionA candidate's application against a JobOrdercandidate, jobOrder, status, dateWebResponseAll editions
SendoutCandidate package sent to a client contactcandidate, jobOrder, clientContact, dateSentAll editions
PlacementConfirmed hire / contract assignmentcandidate, jobOrder, dateBegin, employmentTypeAll editions
Note, Task, AppointmentEngagement and activity historyaction / subject, dateAdded, commentingPersonAll editions
Custom Objects (1–10 per parent)Customer-defined sub-records attached to core entitiesSchema defined by Bullhorn Support firstFront Office Growth/Enterprise: 10 per entity with 55 fields each; Bullhorn ATS: 2 per entity; ATS Growth: none16

Bullhorn's upsert key is externalID — a single-line text field on every core entity that you set yourself and use to match incoming rows against existing records3. Several entities also expose customTextX fields that can be promoted to external-ID-style match keys via the Data Loader ExistField setting3.

Plan for externalID on day one: stamp the source primary key (or a UUID) into every row before export, and use it on every re-run so updates are deterministic. Without externalID, the Custom Import wizard matches on a name/email heuristic unsafe for production142.

Custom field edit types determine validation and storage; the catalogue below covers what you can model and the limits that apply17.

Field typeLimitNotes
Custom Text100 chars (Text) or longer for Text Block / DHTML EditorCan be changed to most other types except Float, Money, Date/Time, Integer17
Custom Float / Numeric / Money / PercentageNumeric storage; FLOAT / NUMERIC / MONEY specialisationsFloat can convert only to Integer, Money, Mini Picker or Drop-Down17
Custom Integer32-bit integerCan only be changed to Mini Picker or Drop-Down17
Custom Date / Date-TimeStored in Eastern Time on Bullhorn serversTime portion is often ignored on Date-only fields; convert source datetimes carefully27
Drop-Down / Mini Picker (picklist)Defined per field in Field MappingsInternal value vs display label distinction matters
Check BoxBooleanOnly Text Block and DHTML Editor fields can be retyped to Check Box17
Custom Objects per parent entity10 / 2 / 0 per tier; 55 fields eachFront Office Enterprise / Bullhorn ATS / ATS Growth respectively16
Categories (industry, skill, specialty)Tag-style attached to Candidate, ClientContact, JobOrder, PlacementMulti-value; mapped through Business Sector and Specialty parent lists

Relationships in Bullhorn are modelled as to-one and to-many associations between entities — JobSubmission.candidate is to-one, Candidate.notes is to-many. The Data Loader resolves them by externalID in cross-reference columns.

There is no native cascade-delete: deleting a parent does not delete child Notes, JobSubmissions or Appointments, a behaviour to reproduce via Bullhorn Automation or scripted cleanup if your source relied on it.

Pre-migration prep — the work before you touch Bullhorn

What must be true on the source, the destination, and across the team before the first row hits the Data Loader.

The single best predictor of a clean Bullhorn migration is how much work you do on the source side before the first Data Loader command runs. Bullhorn's own guidance on data hygiene notes that stale candidate records, duplicate emails and outdated Categories are the main reason post-migration search results drift from what recruiters expect29.

The single best predictor of a clean migration is how much work you do before the first Data Loader command runs.

Treat the source export as raw material that needs shaping to Bullhorn's expected formats — email lowercased, phone normalised, picklist values rewritten to destination drop-down values, dates as MM/DD/YYYY or ISO-8601, and owners resolved to Bullhorn usernames.

Source-side prep

  • Audit and dedup the source candidate database before export — email-case-only duplicates, role-based addresses and obviously stale records (last-touched 5+ years ago, never placed) should be pruned now, not after they hit Bullhorn.
  • Stamp externalID on every source record — Candidate, ClientContact, ClientCorporation, JobOrder, JobSubmission and Placement. Use the source primary key or a UUID. This is the single most-important prep task because every re-run, reconciliation query and Automation lookup depends on it3.
  • Normalise picklist values for Candidate status, JobOrder status, JobSubmission status, Placement employmentType and every custom drop-down — Bullhorn matches on the Field Mappings value, not the display label, and silently drops rows targeting undefined values62.
  • Decide resume-file scope. Each candidate has zero, one or many resumes. Decide latest-only, all-versions, or none — the resume leg is its own pipeline that runs after Candidate rows land.
  • Convert dates to Eastern Time. Bullhorn stores all datetimes in ET on the server regardless of user timezone — a date loaded with no offset is interpreted as ET midnight, silently shifting dates by up to 24 hours for non-US-east sources2771.

Destination-side prep

  • Provision a sandbox — Bullhorn supports Developer, Partial and Full-Copy Sandboxes refreshed daily, weekly and monthly, with Partial capped at 5 GB and 10,000 records per object92156. Use Partial or Full-Copy for the dry-run.
  • Provision Corporate Users first, ideally via SSO, and assign User Types and Departments before importing — owner assignment falls back to the load user if a referenced owner does not exist133.
  • Pre-create every custom field in Admin → Field Mappings on the right entity with the right edit type — Custom Float, Integer, Text and Date have asymmetric retype rules that catch teams later17.
  • Pre-create every Custom Object via a Bullhorn Support ticket — Custom Objects cannot be created through the UI directly16160, and they must exist before child rows can be loaded.
  • Set Resume Parser settings. Enable email-based resume parsing via support ticket if backfilling through the parser, and decide which parsed fields overwrite vs. fill blanks106.

People prep

Cutover only works if humans cooperate. Lock down a source-system freeze window — typically 24 to 72 hours for teams whose recruiters live in the system. Train recruiters on Candidate search, JobSubmission status transitions and the Notes tab before go-live. A typical small-agency migration runs two to six weeks of elapsed time104; data depth, custom Categories and resume volume drive the upper end.

Import mechanisms: UI wizard and Data Loader

Two paths in, each with different limits and shapes. Picking the wrong one is how staffing-agency migrations stall at scale.

Bullhorn exposes two main load paths and the right one depends on dataset size, entity mix, and whether you need to re-run idempotently. The Custom Import wizard covers small Candidate/Contact/Lead loads. The Bullhorn Data Loader handles repeatable, large CSV loads across all entities.

Custom Import wizard

The native Custom Import lives at Menu → Tools → Custom Import142. It accepts CSV only — Excel files must be saved as CSV first — and supports just three entities: Candidate, Contact and Lead32. The flow: pick Record Type, upload CSV, accept the auto-mapping, name the template, click Perform Import, review the first 100 records, click Next exactly once, and wait.

The single most-important warning in the Bullhorn docs: clicking Next more than once on the preview screen creates duplicate records142. Teams that lose patience because the page appears unresponsive find every candidate doubled. Recovery: mass-delete the newly-added rows (they default to Imported status) and re-import the cleaned file133.

Bullhorn Data Loader

The Bullhorn Data Loader is an open-source Java tool published at github.com/bullhorn/dataloader and maintained by Bullhorn314. It runs from the command line against a directory of CSV files whose names start with the target entity — Candidate.csv, JobOrder.csv — and supports load, update, delete and convertAttachments commands.

Configuration lives in dataloader.properties, where the ExistField setting declares the upsert key per entity (typically externalID, but any unique field works)3. With ExistField set, Data Loader does upsert; with it commented out or absent, every row is a fresh insert.

Data Loader handles cross-reference associations via column names like clientCorporation.externalID — set the source-side parent key in that column and Data Loader resolves it at load time. The same pattern works for Categories, Business Sector, Specialty and Custom Object parents.

Mapping your data into Bullhorn

The longest section — because field mapping is where almost every migration that fails actually breaks.

Mapping is where every staffing-ATS migration earns its scars. The schema decisions in your mapping spreadsheet determine whether recruiters find candidates on day two, whether placement reports work on day five, and whether the team trusts the data by day thirty.

Work entity by entity in strict import order: ClientCorporations first (so JobOrders and ClientContacts can associate), then ClientContacts, Candidates, JobOrders, JobSubmissions, Sendouts, Placements, Notes / Tasks / Appointments, and resume files and Custom Objects last.

Candidates

Common source → Bullhorn Candidate mapping
SourceDestinationNote
candidate_idexternalID (upsert key)Stamp source primary key here; set as ExistField in Data Loader3
first_name / last_namefirstName / lastNameRequired; preserve case as candidate-entered
emailemailLowercase, trim, validate; not the primary upsert key
phonephone / mobileBullhorn does not enforce E.164; normalise upstream for searchability
status / pipeline_stagestatusMap to a value defined in Field Mappings (e.g. Active, Placed, Inactive) — undefined values silently fail62
owner / recruiterowner (CorporateUser association)Map by username or CorporateUser ID — unresolved owners default to Imported133
skills / tagscategories (Specialty / Skill tagging)Multi-value; use semicolon delimiter and pre-create parent values
source / referral_sourcesource field + customText for legacy valueBullhorn's source list is restricted; collapse out-of-range values to Other
gender / ethnicity / veteran / disabilityEEOC fields on CandidateSensitive; respect retention and consent policies before loading130

ClientCorporations and ClientContacts

Common source → Bullhorn Client mapping
SourceDestinationNote
company_nameClientCorporation.nameRequired
company_idClientCorporation.externalIDUpsert key for cross-reference from JobOrder, ClientContact
industrybusinessSectorIDTo-one to the Business Sector picklist; pre-create values
contact email + nameClientContact fields with clientCorporation.externalID columnCross-reference resolves the parent company at load time
parent / subsidiaryparentClientCorporation associationRun as a second pass after all companies have IDs

JobOrders, JobSubmissions and Placements — the ATS deep dive

The job-requisition pipeline runs JobOrder → JobSubmission → Sendout → Placement, with status transitions logged as history on each entity. A JobOrder is the open requisition (e.g. Senior RN, Boston), a JobSubmission is a candidate's application against it, a Sendout is when that submission is packaged and sent to the client, and a Placement is the confirmed hire.

Recreate every JobOrder status (Open, Covered, Lost, Closed) and every JobSubmission status (New Lead, Internal Submission, Client Submission, Interview Scheduled, Offer Extended, Placed, Rejected) in Admin → Field Mappings before loading. Rows targeting an undefined status are silently rejected62.

Common source → Bullhorn JobSubmission mapping
SourceDestinationNote
application_idJobSubmission.externalIDUpsert key
candidate_idcandidate.externalID (cross-ref)Candidate row must exist first or the JobSubmission row fails
job_idjobOrder.externalID (cross-ref)JobOrder row must exist first
applied_atdateWebResponseRequired; Bullhorn stores in ET — convert source UTC offsets explicitly71
current_stagestatusMap to defined Field Mappings value; undefined values fail silently62
stage_historySequence of update operations per status transitionJobSubmission status history is built by repeated updates, not by importing a history table
source / where_fromsource field + categoryIDDrives Source Effectiveness Report157

JobSubmission status transition history is one of the most-asked-about pieces of an ATS migration and one of the least-supported on import. Bullhorn does not expose a status-history table — the audit trail is built by repeated updates that each generate a history row134. To preserve the timeline, capture each transition as (submission_id, status, timestamp, user) and replay updates in date order, accepting that the modifying user will be the migration user, not the original recruiter.

Alternatively, store the legacy stage history verbatim in a Custom Text Block field on JobSubmission so it stays searchable, and let live history accrue forward from cutover.

Candidate sources, EEOC and Categories

Candidate source tracking lives on the source field plus a categoryID link to a Source category list. EEOC data (ethnicity, gender, veteran, disability) lives on dedicated Candidate fields and is reportable through Bullhorn's Standard Source Effectiveness and Diversity reports157. Treat EEOC fields as sensitive: confirm the source export is permitted under your retention policy and that the destination's privacy posture matches130.

Categories in Bullhorn are the tagging system — industry, skills, certifications, geographic specialties. They attach to Candidate, ClientContact, JobOrder and Placement. Pre-create the parent Category lists in Admin → Categories, then resolve source tags to Bullhorn Category IDs via a lookup table during transform. Mismatched Category names silently drop on import.

Resumes and file attachments

Resume and attachment migration is its own pipeline that runs after the Candidate rows land. The Custom Import wizard does not handle files; the supported paths are Data Loader's convertAttachments and loadAttachments commands, which read a CSV of {candidate externalID, file path, file type}74, and the Bullhorn Automation Resume Upload survey for candidate self-service backfill106.

File-size cap for record attachments is 20 MB per file; supported types include doc, docx, odt, rtf, html, pdf, txt for resume parsing, plus PDF, MS Word, Excel and images for general attachments7273. For large resume estates, most agencies keep originals in S3 or Azure Blob, load only the latest resume into Bullhorn, and store the archive deep link in a Custom URL field.

Notes, Tasks and Appointments — historical activity

Bullhorn supports importing Notes, Tasks and Appointments with their original dateAdded timestamps via Data Loader52. Each Note carries an action (Call, Email, Meeting, General), commentingPerson (recruiter), commentsText (body), and one or more associations to Candidate, ClientContact, JobOrder or Placement parents.

Bullhorn Notes do not support rich-text formatting — pasting HTML, images or charts is rejected and only plain text survives52. Convert source rich-text bodies to plain text or a Markdown-style structure during transform, otherwise the body arrives blank.

Custom-field mapping strategy

Resist the urge to map every source custom field one-to-one. Migrate only the custom fields used by an active recruiter workflow or report in the last 12 months. Excess fields weaken Field Mappings governance, slow Bullhorn Search indexing, and make Reporting harder to wire.

For picklist fields whose source values do not match the destination, either: (1) extend the destination drop-down in Admin → Field Mappings, (2) collapse adjacent values during transform, or (3) introduce a parallel Custom Text field holding the legacy value verbatim. Calculated / formula fields do not import — Bullhorn has no formula type, so source formulas must be replicated via Bullhorn Automation or pre-computed before export.

Audit trail, ownership and original timestamps

Bullhorn maintains an audit trail on the Activity tab of each record, with the modifying user recorded as the user that initiated the change134. System-managed dateAdded and dateLastModified can be overwritten on creation via Data Loader for most entities — unusual for the category and a quiet win for historical timelines.

However, dateAdded is interpreted in Eastern Time on the Bullhorn server2771. A source datetime of 2024-08-14 12:00 NZST round-trips as 2024-08-14 00:00 ET if you do not convert, shifting dates by up to 24 hours for non-US recruiters. Convert every datetime to ET explicitly during transform and document the convention in your migration spec.

Owner assignment during import works only if the username or CorporateUser ID exists at load time; rows whose owner cannot be resolved are imported with the load user as owner, silently breaking Pulse attribution and per-recruiter reporting133.

The pitfalls that derail Bullhorn migrations

Specific failure modes — ranked by impact, each tied to the exact Bullhorn mechanism that breaks.

Validation and cutover

What to verify after the import job, in what order — and how to fail safely when something is wrong.

Validation is the bridge between Data Loader finishing and recruiters being allowed in. A three-stage validation works best: a 10 percent pilot load with recruiter spot-checks, the full load with real-time row-count monitoring, and a 30-day audit driven by Bullhorn Reporting. The most reliable signal is recruiters verifying their own desks — they know what right looks like better than any reconciliation script.

Build a reconciliation queries spreadsheet that compares source and destination on each of these counts. Anything outside a 0.5 percent variance gets investigated before users get login access.

  • Total Candidates loaded vs. source — minus deliberately excluded rows (stale, opt-out, duplicate emails).
  • Total ClientCorporations and ClientContacts loaded vs. source — checking that name-based collapse did not over-merge separate clients.
  • Total JobOrders per status vs. source, plus sum of salary per JobOrder.status — a non-trivial dollar variance signals a status-mapping error or currency-precision drop.
  • Total JobSubmissions per JobOrder vs. source, and JobSubmission counts per status — confirms the candidate pipeline shape per requisition matches.
  • Total Placements per employmentType (Contract, Contract-to-Hire, Perm) and sum of payRate per period — drives billing-side reporting from day one.
  • Notes, Tasks and Appointments per entity with dateAdded round-tripped — date-bucket the comparison to confirm timestamps were not silently shifted by the ET conversion27.
  • Owner distribution per entity — group by owner.username and confirm no record landed unowned that should not have133.
  • ExternalID integrity — count distinct externalIDs per entity; any nulls or duplicates indicate the upsert key was not consistently set3.

On top of reconciliation, run a manual spot-check: pick 30 random Candidates across statuses and verify each field against the source UI. Pick five high-value JobOrders and trace the full association graph — ClientContact, Candidate, JobSubmission, Sendout, Placement, Notes. If discrepancies show up in three or more of the 30, halt the load, fix the root cause, and re-run by externalID upsert.

Bullhorn does not ship a native bulk-undo. The recovery path: every imported row carries a Custom Text field stamped Import Batch ID, and if catastrophe strikes, a mass-delete in Admin → Mass Update filtered by that batch ID rolls the import back124127. Bullhorn Support can also perform a Hard Delete of Existing Data, but the operation is one-way and irreversible127.

The real rollback strategy remains: export everything to S3 before the import starts, stamp every imported row with an Import Batch ID, and bulk-delete by that batch ID if recovery is needed.

Cutover sequencing: (1) source ATS goes read-only and the desk is notified; (2) a final delta export captures everything changed during the test window; (3) delta is loaded via Data Loader against externalID; (4) reconciliation runs; (5) recruiters get login access and a 48-hour hyper-care window; (6) source decommission is scheduled 30 to 90 days out, never same-day.

Migration partners and tools

Bullhorn Marketplace partners, ETL vendors, specialist migration shops — what each is good for and how to choose.

The Bullhorn Marketplace lists 300+ pre-integrated technology partners and a smaller cohort of certified implementation consultancies that handle migration work112. Bullhorn itself ships an in-house Implementation team that manages most small and mid-size agency migrations end-to-end, typically two to six weeks of elapsed work for mid-size firms104.

For agencies that want external help, the Bullhorn Marketplace lists a tier of long-standing Bullhorn-focused consultancies112. A separate band of specialist migration vendors focuses narrowly on Bullhorn import paths — published timelines run 1 to 3 days for a full migration on smaller datasets, and resume-extraction-as-a-service offerings handle parsing from email inboxes plus bulk loading.

On the ETL and iPaaS side, Fivetran, Airbyte, Workato and Integrate.io all support Bullhorn as source or destination. Their role is rarely the migration itself — it is the staging layer that lands source data into a warehouse, the transformation layer that converts picklist values and resolves owner usernames, and the ongoing-sync layer post-migration.

Workato is common where the migration is bundled with workflow automation rebuilds; Fivetran and Airbyte are common picks for warehouse-first teams that want to reverse-ETL into Bullhorn.

Managed-migration cost ranges vary widely. A clean homegrown-database-to-Bullhorn load of under 25,000 Candidates with no resume backfill often lands in the $2,000–$10,000 range on top of the Bullhorn license. A Crelate-to-Bullhorn or Greenhouse-to-Bullhorn project with JobSubmission history, Custom Objects, resume migration and Automation rebuilds typically runs $15,000–$60,000, driven by record count, custom-field complexity and resume-file volume.

For teams that want to outsource the migration end-to-end, FlitStack specialises in Bullhorn migrations and handles the field mapping, externalID upsert design, resume-file pipeline, JobSubmission history rebuild and validation work in Sections 5 and 7. Pricing is fixed-fee, based on record count and source platform, with separate line items for Custom Objects and resume-file depth so scope is transparent before signature.

This is one of several legitimate paths — the right choice depends on whether you want the in-house Bullhorn Implementation team, a Marketplace partner like Newbury, an iPaaS-first approach with Fivetran or Workato, or a specialist migration vendor. [Explore FlitStack →](/contact)

Bullhorn ATS & CRM migration checklist

An eight-phase, task-by-task punch list for moving candidates, resumes, contacts, jobs, submissions, sendouts, placements, and historical activity into Bullhorn ATS. Typical timeline: 6–16 weeks.

0. Decide & Plan9 tasks
  • List the in-scope Bullhorn entities by name. Decide which of ClientCorporation, ClientContact, Lead, Opportunity, JobOrder, Candidate, JobSubmission, Sendout, Placement, Note, Task, and Appointment are migrating. Record each as in or out of scope.If skipped: Mid-project entity additions force re-running mapping, sandbox tests, and the entire load-order sequence from the start.
  • Confirm the Bullhorn edition and the Custom Object tier it grants. Front Office Growth/Enterprise allows up to 10 searchable Custom Objects per entity; Bullhorn ATS allows 2; ATS Growth allows none. Confirm the tier in writing before mapping any non-standard data.If skipped: A mapping that depends on Custom Objects that the edition does not support forces a last-minute redesign or an unplanned tier upgrade.
  • Define the historical-data scope per entity. Decide how many years of Candidates, Notes, Tasks, Appointments, JobSubmissions, Sendouts, and Placements are in scope. Record an explicit cut-off date per entity.If skipped: Without a cut-off, the export expands into a multi-year dump that no one budgeted for transforming.
  • Decide whether to keep the legacy ATS as a read-only archive. Older Notes, closed Placements, and resume revisions are often cheaper to leave in read-only legacy than to re-shape for Bullhorn. Document the archive plan.
  • Assign a single accountable migration owner (DRI). Name one person responsible for go/no-go on cutover. Document an escalation chain that includes Recruiting Ops, Sales Ops, IT, and Compliance representatives.
  • Capture GDPR, EEOC, and candidate-consent obligations. Document the lawful basis for migrating candidate personal data, the EEOC re-categorisation strategy, and the retention rules that change on cutover. Capture the data-processing agreement before exporting anything.If skipped: Legal blocks the import on go-live day when candidate consent or retention review was not completed earlier.
  • Set the cutover date, source freeze window, and parallel-run window. Choose a date that avoids quarter-end placement push, payroll close, and large open job orders. Define the freeze window during which the source ATS goes read-only.If skipped: A cutover during a placement push forces recruiters to log activity in two systems and reconciliation breaks.
  • Document the migration success criteria in writing. List the row counts, candidate-pipeline reconciliations, and user-acceptance checks that must pass before the project is closed. Include the source-system decommission date.
  • List explicitly out-of-scope items. Examples: deactivated recruiter logins, training-platform completions, legacy job board scraped data, old report layouts. Capture them so they do not silently re-enter scope mid-project.
1. Pre-Migration Prep23 tasks
  • Run dedup on source Candidate records using email plus phone. Resolve duplicates in the source before export so two profiles do not land as one Candidate in Bullhorn. Email alone is unreliable for contractors who reuse personal addresses.If skipped: Duplicate source rows merge into a single Candidate and historical JobSubmissions attach to the wrong person.
  • Run dedup on ClientContact and ClientCorporation using domain plus normalised company name. Strip 'Inc', 'LLC', 'Ltd' suffixes before comparison. Resolve duplicates so JobOrders attach to one parent company on the Bullhorn side.If skipped: Pipeline reports double-count revenue across split company records.
  • Standardise phone numbers to E.164 format. Bullhorn stores phone as a string; normalise upstream so downstream search and SMS integrations behave consistently.
  • Standardise email casing to lowercase. Lowercase emails before export. Mixed casing breaks email-based dedup keys at import time.
  • Identify and resolve Candidates with missing required fields. Bullhorn requires at least firstName, lastName, and one identifier (email or phone) for a Candidate to load. Patch or drop incomplete rows before export.If skipped: Required-field rejections show up mid-import and stop the load until manual triage.
  • Identify Candidates with no resume on file. Decide whether resume-less Candidates migrate. Capture the decision in writing so they are not silently dropped or duplicated later.
  • Resolve orphan JobSubmissions, Sendouts, and Placements. Find submission/sendout/placement rows whose Candidate or JobOrder no longer exists. Either restore the parent or drop the orphan row before export.If skipped: Orphan rows fail the relationship load and force a stop-and-fix cycle inside the cutover window.
  • Audit Categories, Specialties, and BusinessSectors in the source. List every category value in use and decide which map 1:1 to Bullhorn, which merge, and which retire. This becomes the picklist-mapping spreadsheet later.
  • Export current record counts per entity as a baseline. Capture row counts for Candidate, ClientContact, ClientCorporation, JobOrder, JobSubmission, Sendout, Placement, Note, Task, and Appointment. This is the Phase 6 reconciliation target.If skipped: Without a baseline, post-migration validation cannot prove completeness.
  • Provision the production Bullhorn instance and confirm regional data centre. Confirm the data centre region for the new instance and capture it in the runbook.
  • Provision a Bullhorn sandbox refreshed from production metadata. Sandbox metadata must match the production schema the migration will eventually load into. Refresh the sandbox before each major sandbox dry run.If skipped: Sandbox results that do not reflect production schema mislead the go/no-go decision.
  • Create all recruiter, sales, and admin users with appropriate access. User IDs must exist before record-owner fields can reference them. Match source usernames to destination usernames in a lookup table.If skipped: Records load owned by the migration service account and ownership reports break until manually reassigned.
  • Configure system-wide timezone and confirm the Eastern Time storage rule. Bullhorn stores all dateTime values in Eastern Time on the server. Document the offset between Eastern Time and every source timezone the data spans.If skipped: Datetime values silently shift by hours and audit-trail timestamps no longer match the source.
  • Raise a Bullhorn Support ticket for every Custom Object you plan to use. Custom Objects must be created by Bullhorn Support before they accept any data. Submit the ticket in Phase 1, not the day before cutover.If skipped: The Custom Object provisioning lead time blows the cutover window because the ticket sat unfiled.
  • Create every custom field on Candidate, ClientContact, ClientCorporation, JobOrder, Opportunity, and Placement before any import. Importing into a field that does not yet exist silently drops the data. Build all custom fields in Field Mappings up front, with the correct edit type (Text, Integer, Float, Money, Date, Date/Time, Check Box, Drop-Down, Mini Picker, DHTML Editor).If skipped: Custom data lands in nothing and is not discoverable until users complain weeks later.
  • Lock down the destination edit-type for every custom field. Custom Float fields can only later be changed to Integer, Money, Mini Picker, or Drop-Down. Custom Integer fields can only change to Mini Picker or Drop-Down. Pick the right edit type the first time.If skipped: An incorrect edit type forces field deletion and re-creation, which loses any data already imported.
  • Pre-populate every picklist value the source data will deliver. Bullhorn's import rejects rows whose picklist value is not in Field Mappings. Add every source value (or its mapped equivalent) to the destination picklist first.If skipped: Mid-import picklist rejections halt the load until each new value is added by an admin.
  • Configure Categories, Specialties, BusinessSector, and custom Categories. These are folksonomy tagging structures. Build the complete value list in Bullhorn before importing tagged rows.
  • Pause every integration on the destination side until cutover. Disable Marketplace integrations, Bullhorn Automation flows, distribution-list email triggers, and VMS Sync. They must not fire during bulk import.If skipped: Migrated records trigger candidate emails, automation drip campaigns, or VMS resubmissions on day one.
  • Configure Resume Parser settings with overwrite behaviour documented. Re-parsing a resume can overwrite already-loaded Candidate fields. Confirm whether parsing is enabled by default and decide whether migrated resumes should be parsed at all.If skipped: Parser overwrites carefully-mapped fields the first time a recruiter opens a record.
  • Announce the freeze window to every recruiter and sales user. Communicate the freeze date, the read-only date, and the go-live date at least two weeks in advance. Confirm receipt from each team lead.
  • Schedule end-user training on Bullhorn list views, Tearsheets, and the Notes tab. Segment training by role: recruiters, sales, and admins each use different list views and dashboards.
  • Designate first responders for the first 72 hours post-cutover. Name two admins on rotating shifts who can triage user issues, run quick reports, and escalate to Bullhorn Support if needed.
2. Source Export13 tasks
  • Export Candidate records as CSV with every standard and custom field. Include id, firstName, lastName, email, phone, address fields, status, source, owner, createdAt, modifiedAt, every custom field, and the source-system external ID.
  • Export resume binaries to a directory keyed by source Candidate ID. Capture original filename, MIME type, upload timestamp, and the parent Candidate's source ID. Common formats: doc, docx, pdf, rtf, odt, txt, html.If skipped: Resumes without a parent ID become orphan files that cannot re-attach in Bullhorn.
  • Export ClientCorporation and ClientContact as separate CSVs. ClientContact rows must include the source ClientCorporation ID so the parent-child relationship survives transform.
  • Export Lead and Opportunity records. Capture status, owner, related ClientCorporation/ClientContact, and any custom fields. Leads convert into Candidates or ClientContacts in Bullhorn; document the conversion choice per row.
  • Export JobOrder records with parent ClientCorporation ID. Include status, employmentType, payRate, billRate, clientContact reference, owner, and dates. JobOrder is the parent for every JobSubmission and Sendout.
  • Export JobSubmission, Sendout, and Placement rows as separate files. Each file must include the Candidate ID and JobOrder ID for relationship rebuild. Include status history fields where available.If skipped: Without both parent IDs, the pipeline rebuild collapses and reports cannot show placement history.
  • Export Note rows with related-entity IDs and Eastern Time timestamps. Each Note must capture the entity type (Candidate/ClientContact/JobOrder/etc.), the entity ID, the action type, the comment body, and the original datetime.
  • Export Task and Appointment rows with attendee references. Capture due date, owner, status, description, and the related Candidate/Contact/Job for each row.
  • Export the user list with usernames, roles, and active status. This becomes the user-mapping lookup table for owner fields. Inactive users may still need to exist for historical attribution.If skipped: Missing user mappings push every record into a single migration account and ownership reports become useless.
  • Export pipeline status definitions, Categories, Specialties, BusinessSectors, and tagging values. These become the picklist-mapping reference in Phase 3.
  • Export non-resume attachments (interview notes, offer letters, signed documents). Capture metadata: parent entity, original filename, MIME type, upload date, and uploader. File-size cap on the destination is 20 MB per file.If skipped: Files above 20 MB silently fail and the missing-document list surfaces only after recruiters look for them.
  • Capture screenshots and export configs of source dashboards, reports, and automations. These are rebuilt by hand in Bullhorn Reports Studio and Bullhorn Automation later. There is no transfer path.
  • Record the exact timestamp of every export. Used to compute the delta capture at cutover and to align the audit trail.
3. Transform & Map24 tasks
  • Build a master mapping spreadsheet for every source field. Columns: source entity, source field, destination entity, destination field, transformation rule, edit type, picklist mapping reference, required-on-import flag, upsert key.If skipped: Without one source of truth, mapping decisions drift between engineers and the final load disagrees with the design.
  • Pick the upsert key per entity. Use the Bullhorn externalID field for every entity that supports it. Document the source field that produces the externalID value (typically the source primary key).If skipped: Without an upsert key, re-runs duplicate rows instead of updating them.
  • Resolve every picklist value mismatch. For each source picklist value, document the destination value. If a value has no destination equivalent, decide and document: add to picklist, merge into another value, or drop the row.If skipped: Field Mappings rejects non-listed picklist values and the row fails the load mid-job.
  • Decide handling for source fields with no destination equivalent. Options: drop, concatenate into the Notes tab, create a custom field, or store in a Custom Object. Apply the decision consistently per entity.
  • Decide how source Leads map to Bullhorn. Bullhorn Lead, Candidate, and ClientContact are different entities. Decide which source Leads become Candidates, which become ClientContacts, and which stay as Bullhorn Leads.
  • Convert every datetime to Eastern Time. Bullhorn stores datetimes server-side in Eastern Time. Apply the timezone shift in transform, not at load time.If skipped: Activities appear hours earlier or later than the source and audit reconciliation fails.
  • Re-encode every text field as UTF-8. Strip BOMs, replace non-UTF-8 bytes, and verify accented characters survive a round-trip through your transform pipeline.If skipped: Mojibake on candidate names blocks search and forces a per-row re-load.
  • Truncate text fields to Bullhorn's edit-type limits. Text fields cap at roughly 100 characters; longer content belongs in Text Block, DHTML Editor, or a Note. Truncate before load with logged overflow rows.If skipped: Right-truncation errors halt the import partway and the failed rows must be patched and re-run.
  • Normalise currency and pay-rate fields to Money edit type. Strip currency symbols, normalise decimals, and store the currency code separately if the source mixed currencies.
  • Strip rich-text formatting from Note bodies and keep plain text plus inline references. Bullhorn Notes do not support HTML images, charts, or rich-text pasting. Reduce HTML to plain text or DHTML-editor-safe markup before load.If skipped: Notes import as garbled HTML and recruiters spend weeks re-formatting by hand.
  • Escape commas, quotes, and newlines inside CSV fields. Wrap field values containing reserved characters in double quotes and double up embedded quotes. Test the file in a CSV parser before upload.If skipped: Misparsed delimiters shift columns and silently corrupt every downstream row.
  • Sequence the load order in the transform output. Required order: ClientCorporation → ClientContact → Lead → JobOrder → Candidate → JobSubmission → Sendout → Placement → Note/Task/Appointment → file attachments. Each downstream entity references upstream externalIDs.If skipped: Loading out of order produces orphan rows that the next stage cannot resolve.
  • Map every source owner username to a Bullhorn CorporateUser ID. Use the Phase 2 user lookup table. For inactive recruiters with no Bullhorn login, decide between a 'historical user' shared account or assignment to the migration service account.
  • Decide and apply the historical-timestamp strategy. Bullhorn audit-trail timestamps reflect the loader identity. Either set custom Date/Time fields like 'Original Created' to preserve source timestamps or accept the import-day timestamp on the system field.If skipped: Tenure, time-to-fill, and source-of-hire reports show every record as 'created today' until the custom field is rebuilt.
  • Decide and apply the file-attachment strategy. Either re-upload binaries to the Candidate or Placement record, or keep external storage links and store the URL in a custom field. Apply consistently per entity.
  • Stage the Candidate database load with the Resume Parser disabled. Load Candidate rows first with structured fields, then attach resume binaries separately, and only enable parser-driven re-parse if the source data is missing structured fields. Re-parsing overwrites already-loaded values.If skipped: Parser-driven imports overwrite cleanly mapped Candidate fields with whatever the resume happens to contain.
  • Rebuild the JobOrder → JobSubmission → Sendout → Placement pipeline by externalID linkage. Each downstream row references the JobOrder externalID and the Candidate externalID. Validate the join in transform before generating the load file.If skipped: Pipeline reports collapse because submissions and placements lose their JobOrder parent.
  • Map Candidate Source via the source's categoryID field plus a custom Source field where granularity matters. Bullhorn's standard source list is coarse. For nuanced source attribution (referrer name, campaign code, job-board name), create a Custom Text field on Candidate and route detail there.If skipped: Marketing attribution reports cannot answer 'which channel placed which candidate' because every row reads 'Other'.
  • Re-categorise EEOC fields (ethnicity, gender, veteran status, disability status) into Bullhorn picklists. Map source values to the destination EEOC picklists exactly. Capture the candidate-consent timestamp in a custom Date/Time field where the source has it.If skipped: EEOC reports run on populated fields with inconsistent values and the OFCCP audit trail breaks.
  • Translate source tags into Bullhorn Categories, Specialties, BusinessSector, and custom Categories. Resolve which tagging system each source value maps into, then write a multi-value join field per entity. Pre-create every value in Field Mappings.
  • Reconstruct JobSubmission status-transition history in custom Date/Time fields. Bullhorn's submission record stores the current status only. Add custom Date/Time fields like 'Date Submitted', 'Date Interviewed', 'Date Rejected', 'Date Hired' and back-fill from source history rows.If skipped: Time-in-stage and recruiter-velocity reports cannot be reproduced after the cutover.
  • Preserve Eastern Time timestamps on every Note, Task, and Appointment. Shift source datetimes to Eastern Time before load. For activities that must show original ownership, populate a custom Date/Time field 'Original Activity Date' rather than relying on the system field.If skipped: Activity feed shows every historical note timestamped at the import moment.
  • Decide whether each support-ticket-gated Custom Object is worth the request. Custom Object creation requires a Bullhorn Support ticket and counts against the edition's tier limit. For each candidate Custom Object, decide: build it, fold the data into existing custom fields, or drop it.
  • Generate the final load files per entity in the Data Loader CSV format. Each file's header row must match Bullhorn entity field names. Filename must start with the entity name so the open-source Java Data Loader CLI can detect the target entity.If skipped: Header mismatch causes Data Loader to silently skip columns and the data lands in nothing.
4. Sandbox Test Migration12 tasks
  • Refresh the sandbox to match production metadata. Custom fields, Custom Objects, picklist values, and Field Mappings must reflect the production target before the dry run begins.
  • Load 1–5% of each entity using the chosen import path. Use Bullhorn Data Loader (open-source Java CLI) for bulk CSVs, or the Custom Import wizard for small Candidate/Contact/Lead sets.If skipped: Skipping the sample run means every defect surfaces during cutover instead of during a low-stakes test.
  • Validate Candidate field-by-field on 10 random sandbox records. Open each in the Bullhorn UI and confirm name, email, phone, address, status, source, every custom field, and the attached resume binary.
  • Verify JobOrder → JobSubmission → Sendout → Placement chains on 10 random pipelines. Confirm each downstream row attaches to the correct JobOrder and Candidate and that the status reflects the source pipeline state.If skipped: Broken chains discovered in production force a stop-and-rebuild during the cutover window.
  • Test long strings, special characters, and embedded newlines in Note bodies. Confirm UTF-8 survives, that quotes and commas escape correctly, and that the Notes tab renders cleanly.
  • Test Eastern Time datetime handling on Notes and Appointments. Pick activities created at 11pm and at 1am source-time and confirm the loaded datetime is correct in Bullhorn's UI.If skipped: Late-evening activities silently land on the wrong day after the timezone shift.
  • Test picklist values across every custom Drop-Down and Mini Picker field. Pick one record per value and confirm the field renders the right label and that searches return the row.
  • Test the Custom Import wizard end-to-end and respect the 'click Next once' rule. On step 7 of Custom Import, click Next exactly once. A second click duplicates every record that just imported. Document this behaviour in the runbook.If skipped: A panicked double-click during cutover doubles the loaded data and a mass-delete-and-restart eats the day.
  • Run a full-volume sandbox test where the sandbox allows it. Time each entity load and extrapolate to production volume. Confirm the projected runtime fits inside the cutover window with margin.
  • Have a domain expert spot-check the sandbox data. A senior recruiter and a senior sales user each open 25 records and judge whether the migrated data is usable.
  • Capture sandbox row counts per entity and compare to source. Reconcile any delta before sandbox sign-off; deltas larger than the rejection log indicate silent data loss.
  • Get written sandbox sign-off before scheduling cutover. Migration owner, recruiting lead, sales lead, and IT each sign off. Capture the signed document in the runbook.
5. Production Cutover13 tasks
  • Confirm source-system freeze and verify no writes in the last hour. Run an audit query against the source for any modifiedAt newer than the freeze timestamp. Resolve before continuing.If skipped: Late source-side writes never make it to Bullhorn and surface as missing data weeks later.
  • Take a final delta export from the source. Capture rows changed between the Phase 2 baseline export and the freeze timestamp. These ride into the cutover load.
  • Re-confirm every integration on the destination is paused. Bullhorn Automation flows, Marketplace integrations, and VMS Sync must be paused before the first row lands.If skipped: Migrated records trigger candidate emails or automation drip campaigns the moment they land.
  • Load ClientCorporation rows first. Use Data Loader with the externalID as the upsert key. Capture the job id, row count, and rejection log.
  • Load ClientContact rows with parent ClientCorporation externalID. Confirm parent matching by externalID before moving on. Capture the job id and reconcile counts.
  • Load Lead, then JobOrder rows. JobOrder must reference the ClientCorporation externalID. Capture row counts and rejection logs.
  • Load Candidate rows with externalID upsert. Run Data Loader against Candidate CSVs. Confirm row count, rejection log, and that resume parser remained disabled during the run.If skipped: Parser auto-runs and overwrites freshly-loaded structured Candidate fields.
  • Load JobSubmission, Sendout, and Placement rows in that order. Each references Candidate and JobOrder externalIDs. Confirm every parent ID resolved before counting the load successful.If skipped: Orphan submissions or placements break pipeline reports and require per-row patching.
  • Load Notes, Tasks, and Appointments referencing the related entity IDs. Confirm Eastern Time timestamps survived the load and that the Activity tab renders the correct date.
  • Upload resume binaries and other file attachments to the parent record. Use the parentEntity + parentId pair. Respect the 20 MB per-file ceiling and log every oversized file for separate handling.If skipped: Oversized files silently fail and the missing-document list surfaces only after recruiters look for them.
  • Cross-check destination row counts against source at every entity. After each load, compare Bullhorn counts to the Phase 2 baseline plus delta. Investigate any delta before moving on.If skipped: Quietly dropped rows accumulate and undermine the final reconciliation.
  • If any load step fails: stop, diagnose, fix the transform, then re-run idempotently. Never push through partial loads. The externalID upsert keeps re-runs safe.
  • Re-enable integrations, automation flows, and VMS Sync after every load completes. Bring back Bullhorn Automation, Marketplace integrations, and distribution-list email triggers in a documented order.
6. Validate18 tasks
  • Compare total record count per entity: source vs Bullhorn. Reconcile Candidate, ClientContact, ClientCorporation, Lead, Opportunity, JobOrder, JobSubmission, Sendout, Placement, Note, Task, and Appointment counts. Investigate every delta.If skipped: An unreconciled delta becomes silent data loss after the source is decommissioned.
  • Compare active-candidate count by status. Bucket Candidates by status (Active, Placed, Inactive, Do Not Contact) and confirm the destination matches the source distribution.
  • Compare open JobOrder count and total active Placement count. These are the headline pipeline numbers leadership will check on day one.
  • Field-by-field check 50 randomly selected Candidates. Open source and Bullhorn side-by-side and confirm every standard and custom field matches.
  • Field-by-field check 25 randomly selected JobOrders and 25 Placements. Confirm bill rate, pay rate, status, owner, dates, ClientContact, and ClientCorporation all match the source.
  • Verify every custom field has populated values on a representative sample. Pick 10 records per custom field and confirm the values landed; nulls everywhere indicate a column mismatch at load.
  • Verify a sample of ClientContact-to-ClientCorporation parent links. Open 25 ClientContact records and confirm each shows the right ClientCorporation in the Company field.
  • Verify Candidate-to-JobSubmission-to-JobOrder chains on 25 pipelines. Walk each chain from Candidate through to Placement (where applicable) and confirm every relationship resolves.If skipped: Broken chains discovered after the source is read-only force a manual rebuild from screenshots.
  • Verify Note, Task, and Appointment attachments to the right parent entity. Pick 25 historical activities and confirm each appears on the correct Candidate, ClientContact, or JobOrder Activity tab.
  • Verify resume binaries open and parse correctly on 25 random Candidates. Click the resume on each record and confirm it opens; spot-check that parsed fields match the file content.
  • Verify Categories, Specialties, and BusinessSector tags survived. Run a saved search on each tagging dimension and confirm the result count matches the source distribution.
  • Confirm the historical-timestamp strategy worked. If you populated 'Original Created' or similar custom fields, confirm 25 rows show the right source datetimes in Eastern Time.
  • Run the EEOC distribution report and reconcile against source. Bucket Candidates by ethnicity, gender, veteran status, and disability status; confirm the destination distribution matches.If skipped: An OFCCP audit finds a distribution mismatch and the migrated EEOC data must be re-loaded.
  • Run the GDPR retention check and confirm consent dates landed. For EU candidates, confirm the consent-timestamp custom field is populated and the lawful basis is captured.
  • Have 5 recruiters validate their own books of business in Bullhorn. Each recruiter opens their assigned Candidates, JobOrders, and Notes and confirms day-to-day workflow is usable.
  • Have 3 sales users validate their accounts and Opportunities. Confirm ClientCorporation, ClientContact, and Opportunity data is usable for the next sales cycle.
  • Document every issue surfaced by UAT. Triage by severity. Severity-1 issues block Phase 7; everything else goes into the post-migration backlog.
  • Get written sign-off from the migration sponsor. Sponsor, recruiting lead, sales lead, IT, and Compliance each sign before Phase 7 starts.
7. Post-Migration Cleanup12 tasks
  • Announce go-live to every end user with login instructions. Include the Bullhorn URL, single-sign-on instructions, and a where-to-get-help contact for the first 72 hours.
  • Run role-segmented training: recruiters, sales, admins. Cover list views, Tearsheets, the Notes tab, the new candidate list, and Bullhorn Reporting basics.
  • Set the source system to read-only and announce the read-only date. Confirm the source export archive is in long-term storage before flipping read-only.
  • Rebuild reports and dashboards in Bullhorn Reporting. Reports do not transfer between platforms. Rebuild the top 10 reports first and triage the rest by usage.
  • Rebuild automations in Bullhorn Automation. Migration drip campaigns, candidate engagement flows, and birthday/work-anniversary triggers must be reconstructed by hand.
  • Rebuild Marketplace integrations. Reconnect job boards, LinkedIn Recruiter, ZipRecruiter, Indeed, VMS Sync, and any other Marketplace integrations against the new instance.
  • Set up Distribution Lists and Tearsheets that recruiters use daily. Pre-build the lists the largest desks use so the first week is not a manual rebuild project.
  • Schedule the 30-day retrospective. Capture what went well, what did not, and the residual backlog of UAT issues.
  • Set the source-system decommission date. Typically 90 days after cutover, after the final retention window closes. Document who signs off on shutdown.
  • Archive source-system exports and the migration runbook to long-term storage. Encrypt the archive, store the key separately, and record retention duration per compliance policy.
  • Re-enable Resume Parser settings per the documented final state. If you disabled parsing during the load, confirm the final parser behaviour is the one recruiters expect on every fresh resume.
  • Close the migration project formally. Final status report, lessons learned, and a project-closure note distributed to stakeholders.

Questions, answered

Migrating to Bullhorn ATS & CRM: questions

How long does migration to Bullhorn take?

A small-agency migration with under 5,000 Candidates and standard entities runs one to three business days of elapsed Data Loader work. A mid-size agency with JobSubmission history, Custom Objects and resume-file backfill runs two to six weeks of elapsed time, including prep, sandbox dry runs, validation, training and hyper-care.

Can I migrate from Crelate to Bullhorn?

Yes — Crelate-to-Bullhorn is one of the more common staffing migrations. Crelate's pipeline-stage model collapses what Bullhorn splits into JobOrder, JobSubmission and Placement entities, so the mapping work is in re-shaping each Crelate Contact-on-a-Job record into the right Bullhorn entity rather than copying fields one-to-one.

Can I migrate from Greenhouse or Workable to Bullhorn?

Yes, but Greenhouse and Workable are pipeline-per-job ATSs whose object models do not align cleanly with Bullhorn's staffing-industry JobOrder / JobSubmission / Placement chain. Plan for picklist-value rewrites on every status field, scorecard data captured into Custom Text Block fields, and source-tracking values mapped to Bullhorn's Source and Category lists.

Does Bullhorn preserve original timestamps on import?

Partially. `dateAdded` on Candidates, Notes, Tasks and Appointments can be set explicitly on creation via Data Loader and survives correctly on the timeline. But Bullhorn stores all datetimes in Eastern Time on the server, so source datetimes must be converted to ET during transform or they appear to shift by hours.

What's the difference between using the Custom Import wizard and the Data Loader?

Custom Import is a CSV-only UI wizard for Candidate, Contact and Lead entities only, with a known click-twice duplication bug. Bullhorn Data Loader is an open-source Java CLI tool that handles every entity, supports externalID upsert via the ExistField setting, and is the standard path for any non-trivial migration.

Can I migrate Custom Objects to Bullhorn?

Yes, but Custom Objects must be provisioned by Bullhorn Support before any row can be loaded — they cannot be created through the UI by a customer admin. Front Office Growth and Enterprise editions allow 10 Custom Objects with 55 fields each per parent; ATS Growth allows none.

What happens to JobSubmission status history during migration?

Bullhorn does not expose a status-history table that can be loaded directly. The audit trail is built by repeated update operations that each generate a history row, so preserving the original timeline means replaying each transition in date order — or storing the legacy history verbatim in a Custom Text Block field.

Is there an undo or rollback for Bullhorn imports?

There is no native bulk-undo. Stamp every imported row with a Custom Text Import Batch ID and bulk-delete by that field if recovery is needed. Bullhorn Support can perform a Hard Delete of Existing Data for catastrophic scenarios, but the operation is one-way, irreversible, and queued like any support ticket.

Get a quote

Moving to Bullhorn ATS & CRM?

Tell us where your data lives today and roughly how much there is. We scope the migration and the Bullhorn ATS & CRM setup with you, then send a quote.

Get a quote