Skip to main content
Blog

How to Evaluate a Job Postings API Before You Integrate

Six things a live job feed has to get right that a static sample cannot show you: coverage where you sell, discovery lag, closure detection, deduplication, a joinable company id, and what counts as a billed record. Each with a test you run on your own accounts.

Christian PalouChristian Palou•November 19, 2026

A static sample tells you what a job record looks like. It cannot tell you how a feed behaves once it is wired into your product and running every day, and that behavior is where most of the money and most of the surprises are. If you already have a file to inspect, start with how to evaluate a jobs dataset, which covers the data dictionary, counts per source, fill rates and sampling. This page is about the six things that only show up once the data is live, and a test for each one that you run on companies you already know.

Do the tests on your own accounts, not on a demo. Pick 20 to 50 companies from your CRM or your ideal-customer list, ones whose hiring you can already check by hand, and put every provider through the same companies. A provider that looks strong on the global total can still be blind to exactly the accounts you sell to, and the only way to see that is to ask it about yours.

1. Coverage where you sell, not the global total

Every provider leads with a total. Millions of postings, hundreds of thousands of sources, a long country list. None of it tells you whether the companies you care about are in there. A feed can be enormous and still thin in your country, your industry, or the ATS platforms your buyers actually use.

Ask for the breakdown that matches your market, which is postings per country and the share from each job board and ATS. Concentration matters, because if most of the data comes from one place, a single blocked scraper is your outage. So does fit. If you sell to software companies, you want Workday, Greenhouse, iCIMS and Ashby well represented, since a dataset that is mostly national job boards can be huge and still miss your buyers. For reference, our data spans 195 countries and 373k+ sources, with the two largest, Indeed and LinkedIn, at roughly 40% and 19% of postings.

Test it. Take your 20 to 50 known companies and search each one. How many are present, and how many of the roles you know are open actually come back? A provider that returns 3 of your top 20 accounts is not going to get better on the accounts you do not know.

2. Discovery lag, measured against the source clock

"Real-time" is a word, not a number. The figure that matters is the gap between when a job went live at the source and when the provider found it, its discovery lag. A feed that finds roles a week late is fine for market research and useless for a sales signal that has to beat the competition to the inbox.

Ask how it is measured and over what window. The honest version compares the source's own posted time to the moment the provider discovered the posting, on the postings whose source publishes that time. We discover 71% of new jobs within 3 hours, scraping high-volume sources every 10 minutes, medium ones hourly and the long tail daily, and we publish the full discovery curve so you can see where the remaining postings land.

Watch for two tricks. A provider that reports lag against the date it assigned, rather than the source's, is grading its own homework. And a posting's date_posted is often a day with no time, which makes any honest provider look slower than it is. A role posted at 18:00 and found at 18:30 can still count as "same day" or "next day" depending on the clock. Make sure every record carries both a posted date and a discovered date so you can judge this yourself.

Test it. Find a handful of postings you can independently date, say a role one of your accounts announced or a listing you watched go up, and compare the source's posted time to the provider's discovered_at. Do that across a few sources, because lag is not uniform. A company's own career page and a slow regional board behave very differently.

3. Closure detection

Discovering new roles is half the job. Knowing when a role closes is the other half, and far more providers skip it. A feed that only ever adds postings leaves you acting on roles that were filled weeks ago: stale sales signals, a job board full of dead listings, intent data that points at a need that no longer exists.

Ask three things. Do they detect closures at all, how fast, and do they give you a date rather than a flag? A date lets you reconstruct how long a role was open. A flag that silently flips does not. We mark a job closed when we next visit the source and it is gone, record the exact closed_at, and emit a job.closed webhook so you do not have to poll for it. Across our data 18% of roles close within 7 days, 57% within 30 and 85% within 60, with a median around 25 days. That is why the one in five that close inside a week are the ones where catching the closure quickly earns its keep.

Test it. Pick roles at your known companies that you are sure have been filled, and check whether and when the provider marked them closed. A provider with no closure date, or one that lags the real close by weeks, is handing you a growing pile of postings that will never go away on their own.

4. Deduplication, across reposts and across sources

This is the dimension most likely to make two providers' totals differ by 3x, and the per-record bill along with them. One open role usually appears on the company's career page, on its ATS, and on the boards that syndicated it, and it goes up again every few weeks until it is filled. A provider that counts every copy and every repost as a new posting reports a busier labor market than exists. If you are billed per record, you pay for every duplicate, and your "new job" alert fires on a vacancy you already saw.

Ask the question plainly. How do you deduplicate, across reposts and across sources? A provider who has thought about it answers precisely. We keep the first posting and ignore a repost of the same role from the same company within 30 days, and collapse the three to five references a single ATS-driven posting leaves across boards into one job. That makes our totals smaller than providers who count every copy, which in this one case is the point.

Test it. For a company you know is hiring one role, count how many records the provider returns for it. One is right. Five means you are paying five times, and every downstream signal will fire five times.

5. A company identifier you can join on

A job feed is only useful to you if you can connect it to the rest of your data, and that connection lives or dies on the company identifier. A company name is not an identifier. "Walmart", "Walmart #2271" and "Walmart Canada" are three strings and one employer, and no amount of fuzzy matching makes that reliable at scale.

Ask what stable key each company carries, whether a domain, a LinkedIn URL or an internal id, and whether it is populated on most records, not just the big names. The join is also where the agency problem bites. Much of a raw feed is recruiting and consulting firms reposting other companies' roles, so check whether the provider tells you the company type and lets you filter intermediaries out.

Test it. Try to match the provider's companies to your CRM by domain, on your 20 to 50 accounts. Count the clean matches. If you are reduced to matching on name, that is the number you will be fighting for the life of the integration.

6. What counts as a billed record

Price per record is meaningless until you know what a record is. The same role can cost you once or six times depending on how the two dimensions above are handled, so the real question is cost per useful record, after reposts and cross-source copies are removed.

Ask exactly what consumes budget: every returned row, each repost, each source copy, and re-requests of data you already pulled. Then do the arithmetic on your real volume, not the headline price. For reference, our API bills 1 credit per job and 3 per company and charges only when a record is actually returned, so a credit buys a deduplicated role rather than one of its copies.

Test it. Estimate your monthly pull, meaning companies, roles per company and refresh frequency, and price it with each provider's own meter, using the dedup result from test 4. The provider with the lowest per-record price can easily be the most expensive once you count the copies.

The checklist

Put the same questions to every provider, and keep the answers next to each other:

  • Postings per country and per source or ATS, for the markets you sell into, not the global total.
  • How discovery lag is measured, against which clock and over what window, with both a posted date and a discovered date on every record.
  • Whether closures are detected, how fast, and whether you get a date and a webhook or just a flag.
  • How reposts and cross-source copies are deduplicated.
  • The stable company identifier on each record, its fill rate, and whether company type is exposed.
  • What consumes budget, priced against your real monthly volume after deduplication.

Running it on TheirStack

Every test above is one you can run yourself before you commit. A free account and an API key let you pull open and closed postings for your own accounts, with date_posted, discovered_at and closed_at on every record, a domain and a LinkedIn URL for the company, and the deduplication already applied. We also publish what our data does not cover and how freshness is measured, because those are fair questions to put to every provider on your list, our own included.

TheirStack: integrations with AI assistants, automations and CRMs

TheirStack works with the AI assistants, automation tools and CRMs you already use: ask Claude or ChatGPT through the MCP server, send new matches to Clay, n8n, Make or Zapier by webhook, and create leads in Salesforce or HubSpot.

Run these tests on your own accounts

Pull open and closed postings for the companies you already track, with the discovery and closure dates on every record, and see the numbers for yourself.

Start free: 200+ free credits.