Bullhorn integration partners: what to require before you sign

The Bullhorn Marketplace is full of tools promising to extend your ATS and make your team more efficient. But we've seen too many staffing firms get burned by vendors who treat their integration as a marketing checkbox. They sign a contract, only to find the "integration" is just a leaky pipe that creates more manual work and data chaos for their recruiters. The difference between a tool that accelerates your business and one that hobbles it comes down to the depth of its integration.

Shallow integrations force your team to live in two systems. Deep integrations make your tech stack feel like one. As you evaluate Bullhorn integration partners, you need a framework to tell the difference. We’ve learned through building our native Bullhorn integration that true value comes from a fanatical commitment to workflow, data integrity, and support. This is the checklist we use. Don't sign a contract without it.

Why Most Bullhorn Marketplace Integrations Are Shallow

Building a deep, robust Bullhorn integration is difficult, time-consuming, and expensive. It requires extensive knowledge of the staffing lifecycle and the nuances of Bullhorn's API.

Many software vendors, especially those who don't specialize in staffing, opt for the path of least resistance. They build a "minimum viable integration" that can technically pass data from one system to another, allowing them to claim "Bullhorn integration" on their website.

These shallow integrations typically have a few common traits:

• Limited Entity Support: They might create a Candidate record, but they ignore Submissions, Placements, or Notes.
• Delayed Sync: They use inefficient "polling" methods that check for updates every 5, 15, or 60 minutes, meaning your data is always out of date.
• Dumb Logic: They can't handle duplicates intelligently, either creating a mess in your database or blocking legitimate updates.
• Fragile Connections: They break easily when Bullhorn releases updates, and the vendor points fingers instead of providing a solution.

A deep integration, on the other hand, is an extension of Bullhorn itself. It respects your data, automates recruiter workflows, and operates in real-time. It doesn't just move data; it moves your business forward.

Requirement #1: Full Coverage of Core Staffing Entities

A staffing agency doesn't just run on a list of candidates. It runs on the complex relationships between candidates, jobs, submissions, and placements. Any integration that doesn't understand this is fundamentally broken.

Before you even see a demo, ask for a data-mapping document that shows exactly which Bullhorn entities and fields the tool reads from and writes to. At an absolute minimum, demand two-way synchronization for these core entities:

• Candidate: The foundation of everything. The integration must be able to create new candidates and, just as importantly, update and enrich existing ones.
• Client Contact & Corporation: Who is the hiring manager? Which company are they with? An integration that can't link a candidate or job to the right contact and company is creating cleanup work.
• Job/Vacancy: The integration needs to be able to associate candidates with specific, open roles in Bullhorn.
• Submission: This is the critical link. When a candidate is submitted to a job, it creates a Submission record. This is a non-negotiable entity for tracking recruiter activity and pipeline. A tool that only creates a Candidate record and forces the recruiter to manually create the Submission is not a real integration.
• Placement: The ultimate goal. When a candidate is hired, a Placement record is created. This should trigger downstream workflows in the partner tool—like paying out a referral bonus or starting a redeployment campaign.

Imagine your team gets a referral for a Senior GRC Analyst on a contract-to-hire basis. A deep integration would allow you to parse the referral's resume, see they already exist in Bullhorn but with an old phone number, update their record, and submit them to the open GRC role—all from one interface, with every action logged back to Bullhorn automatically. A shallow integration would just create a duplicate candidate record with no link to the job, leaving your recruiter to untangle the mess.

Requirement #2: Real-Time Sync via Webhooks, Not Polling

This is one of the clearest technical differentiators between a modern integration and an outdated one. Ask a potential partner how they synchronize data. If they get cagey or use vague terms, it's a major red flag.

There are two primary methods:

1. Polling (The Slow Way): The partner's server repeatedly asks your Bullhorn instance, "Anything new? Anything new? Anything new?" This is inefficient, resource-intensive, and results in significant delays. A 15-minute polling interval means your recruiter could be contacting a candidate with information that became outdated 14 minutes ago.
2. Webhooks (The Real-Time Way): This is the modern, correct approach. With webhooks, Bullhorn actively sends a notification to the partner's tool the instant an event occurs. A candidate status is updated? A note is added? A placement is made? A webhook fires immediately, and the data is synced in seconds.

The difference is night and day. Real-time sync means your recruiters can trust the data in front of them. It prevents them from chasing candidates who have already been placed or submitting someone who just accepted another offer. Polling-based integrations create a system that is always lagging behind reality. Insist on webhooks.

Requirement #3: Intelligent, Configurable De-duplication Logic

A clean database is a competitive advantage. An integration that pollutes your Bullhorn instance with duplicate records is actively destroying that advantage.

The worst offenders have no de-duplication logic at all. Every new submission, regardless of source, creates a brand new candidate record. This is an immediate deal-breaker.

Slightly better, but still flawed, are integrations with overly simplistic logic that only check for an exact email address match. What happens if a great candidate is referred with their personal email, but they're already in your system with their work email? A simplistic system might either create a duplicate or, worse, block the new information entirely.

A truly deep integration provides intelligent, configurable de-duplication. Look for these capabilities:

• Multi-field Matching: The ability to check for duplicates using a combination of fields (e.g., Email OR Phone OR LinkedIn URL).
• Data Enrichment: The system should identify a potential match and ask, "Is this the same person?" If so, it should enrich the existing record with the new information (like a new phone number or resume) rather than just creating a duplicate or blocking the update.
• Configurability: You should have control over the matching rules. Your firm's data hygiene standards are unique, and the tool should adapt to your process, not the other way around.

Requirement #4: A Support Model That Doesn't Point Fingers

When an integration inevitably has a hiccup, the last thing you want is to be caught in a support vortex between two vendors.

• You to Partner: "The data isn't syncing."
• Partner to You: "Looks like a Bullhorn API issue. You should contact them."
• You to Bullhorn: "My partner says your API is the problem."
• Bullhorn to You: "The API is working fine. The issue is with how your partner is using it."

This is infuriating and unproductive. A vendor with a deep integration takes ownership of the entire data pipeline. Their support team should have deep expertise not just in their own product, but in the Bullhorn API itself. They should be able to use their own logging and diagnostic tools to identify the root cause of a problem without making you the middleman.

Ask them about their support process for integration issues. Who takes the ticket? What are their SLAs? Can they show you their status page for the integration? A confident partner will have clear, immediate answers. A shallow one will deflect.

5 Demo Questions That Reveal Everything

Don't let a slick sales rep control the demo. Take charge and ask specific, workflow-based questions that expose the reality of their integration.

1. "Show me your de-duplication logic in action. Let's try to add a candidate who is already in our Bullhorn but with a new resume and phone number. What happens?" This cuts through the talk and forces them to show, not tell, how they handle data enrichment vs. duplication.
2. "Let's update a candidate's status to 'Placement' in Bullhorn right now. How long will it take for that to be reflected in your tool, and can you explain the mechanism that makes it happen?" This is a direct test for webhooks vs. polling. If they say "it should show up in a few minutes," you know they're using polling.
3. "Walk me through the entire data map. Which specific Bullhorn fields do you write to for a Submission and a Placement?" This tests their coverage of core entities. If they can't write to the Placement entity, for example, you can't automate workflows based on actual hires.
4. "If we have an issue where data stops syncing on a Friday afternoon, what is your exact support process? Who is the first person we talk to, and are they equipped to diagnose Bullhorn API issues?" This tests their support model and commitment to ownership.
5. "Is this integration you're showing me custom-built for this demo, or is it your standard, out-of-the-box product? What aspects are configurable by us post-launch?" This uncovers whether they're showing you vaporware or a real, hardened product.

For a more exhaustive checklist, review these IT staffing CRM integration demo requirements.

How We Built Earshot's Integration The Right Way

When we set out to build Earshot, we knew that a best-in-class referral platform was only half the battle. To be truly effective, it needed a seamless, real-time connection to Bullhorn. We consider ourselves one of the most diligent Bullhorn integration partners because we built our integration based on the very requirements listed above.

Our philosophy is that recruiters should never have to do double data entry.

• Full Entity Coverage: We read and write to Candidates, Contacts, Jobs, Submissions, and Placements. When a referral leads to a hire, we update the Bullhorn Placement record, which can then be used to trigger payroll for the bonus. It’s a closed-loop system.
• Real-Time Sync: We are 100% webhook-based. When a recruiter updates a candidate's status in Bullhorn, that change is reflected in Earshot instantly, keeping the person who made the referral informed in real time.
• Intelligent De-duplication: We use configurable, multi-field matching to identify and enrich existing candidate records, keeping your database clean and powerful.
• Owned Support: We built it, we support it. Our team are experts in the Bullhorn API. When you have an issue, we own it from start to finish.

We believe this is the standard that all Bullhorn referral software and other marketplace tools should be held to. Don't settle for less. The promise of the integrated tech stack is real, but only if you demand excellence from your partners.

How Earshot helps

Earshot is an SMS-native referral platform that helps staffing firms get more high-quality candidates from their existing network. Our deep, real-time Bullhorn integration automates the entire referral workflow, from submission to placement tracking and bonus payouts, ensuring your recruiters can focus on building relationships, not managing data.

If you’re tired of integrations that create more work, see how a deep integration is supposed to function.