DEV Community: Ostrata

One API for Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee jobs (with a daily new-jobs feed)

Ostrata — Mon, 19 Oct 2026 12:27:59 +0000

Many products need fresh job postings: job boards and aggregators, recruiting agencies watching target accounts, sales teams using hiring as a buying signal, market researchers counting roles by function.

The good news is that most tech companies publish their jobs through an applicant tracking system (ATS) with a public, documented job-board API. Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee all have one. The bad news is that there are six of them, with six different JSON shapes, six ways of writing a location, salary fields in some and not others, and none of them tells you which ATS stripe.com uses.

This tutorial uses the Greenhouse, Lever & Ashby Jobs API – All ATS Job Boards, an Apify Actor our team at Ostrata built to put all six behind one input and one output schema. It also has an only-new mode: schedule it daily and each run returns only the postings it hasn't seen before.

What you can put in

The companies field takes one line per company, in any of these forms:

a company domain: stripe.com. The Actor reads the homepage and careers page (plain HTTP, robots.txt respected, max 3 pages) to find the job-board link, and if that fails it tries the domain name as a board slug on each ATS API (ramp.com becomes ashby:ramp)
a job-board URL: jobs.lever.co/spotify, jobs.ashbyhq.com/ramp, boards.greenhouse.io/gitlab, apply.workable.com/huggingface, jobs.smartrecruiters.com/BoschGroup, bunq.recruitee.com
an ats:slug pair: greenhouse:stripe, lever:qonto

Filters and options:

Field	Default	What it does
`keywords` / `excludeKeywords`	–	Keep / drop jobs whose title contains any of these words
`locations`	–	Keep jobs whose location or country contains any of these (`Paris`, `FR`, `Remote`)
`departments`	–	Department or team filter
`remoteOnly`	`false`	Only jobs marked remote
`postedWithinDays`	`0`	0 = no limit
`onlyNew` + `stateStoreName`	`false`, `ats-jobs-state`	Return only jobs not seen in previous runs
`maxJobsPerCompany`	`500`	Postings read per board, before filters
`includeDescription` / `includeDescriptionHtml`	`true` / `false`	Plain-text and HTML descriptions
`useSeedList` + `seedListAts`	`false`	Add a built-in list of about 180 public boards, optionally limited to some ATS
`detectFromWebsite`, `probeApis`	`true`	The two domain-detection strategies above
`concurrency`	`4`	Companies in parallel (each ATS API is also rate-limited per host)

Step 1: Console

Open apify.com/ostrata/ats-jobs-api and click Try for free.
Paste companies, one per line. Mixing domains, URLs and ats:slug lines is fine.
Add title keywords or locations if you want, then Start.
Export the dataset as JSON, CSV or Excel, or connect it to an integration.

Step 2: curl

curl -s -X POST \
  "https://api.apify.com/v2/acts/ostrata~ats-jobs-api/run-sync-get-dataset-items?maxTotalChargeUsd=0.5" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "companies": ["greenhouse:gitlab", "https://jobs.lever.co/spotify", "jobs.ashbyhq.com/ramp",
                  "apply.workable.com/huggingface", "jobs.smartrecruiters.com/Ubisoft2", "bunq.recruitee.com"],
    "keywords": ["engineer", "développeur", "developer"],
    "maxJobsPerCompany": 50
  }'

Step 3: JavaScript (apify-client)

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('ostrata/ats-jobs-api').call(
  {
    companies: ['stripe.com', 'ramp.com', 'huggingface.co', 'qonto.com'],
    locations: ['Paris', 'France', 'Remote'],
    includeDescription: false,
  },
  { maxTotalChargeUsd: 1 },
);

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items.map((j) => ({ company: j.company, ats: j.ats, title: j.title, location: j.location })));

Step 4: Python, with only-new mode (apify-client 3.x)

import os
from decimal import Decimal
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("ostrata/ats-jobs-api").call(
    run_input={
        "companies": ["greenhouse:gitlab", "workable:huggingface"],
        "onlyNew": True,
        "stateStoreName": "gitlab-hf-alerts",   # one name per saved search
        "includeDescription": False,
    },
    max_total_charge_usd=Decimal("1"),
)

for job in client.dataset(run.default_dataset_id).iterate_items():
    print(job["company"], "|", job["title"], "|", job["url"])

How only-new mode works

With onlyNew: true, the Actor keeps the IDs of the jobs it has delivered in a named key-value store in your own Apify account (stateStoreName). On the next run it skips any job whose ID is already stored, so you only receive, and only pay for, new postings.

We tested it on the same two boards (with the state store named ats-test-state). The first run returned all 235 open jobs (229 GitLab, 6 Hugging Face) with isNew: null, because there was nothing to compare against yet. The second run saw the same 235 jobs, delivered 0 and charged nothing. Its SUMMARY record:

{
  "inputs": 2,
  "boardsFound": 2,
  "jobsSeen": 235,
  "jobsFiltered": 0,
  "jobsAlreadySeen": 235,
  "delivered": 0,
  "onlyNew": true,
  "stateStoreName": "ats-test-state"
}

From the second run on, every delivered job has isNew: true. To turn this into a daily alert, save the input as an Apify Task, add a Schedule (for example 0 8 * * *), and attach a webhook, a Slack or email integration, or have your backend read the dataset.

Two details worth knowing: jobs removed from your filters stay "unseen", so they show up as new if you widen the filters later. And the state only keeps jobs that are still online, so a posting that's taken down and republished with the same ID counts as new again.

Real output

One normalized row from our six-board test run (19 Oct 2026, description field omitted):

{
  "id": "ashby:ramp:34413f8d-26bf-4bbc-8ade-eb309a0e2245",
  "ats": "ashby",
  "board": "ramp",
  "company": "ramp",
  "title": "Security Engineer, Cloud",
  "department": "Engineering",
  "team": "Backend",
  "location": "New York, NY (HQ)",
  "locations": ["New York, NY (HQ)", "Remote (Canada)", "Remote (US)", "Miami, FL"],
  "country": "USA",
  "workplaceType": "Hybrid",
  "remote": true,
  "employmentType": "FullTime",
  "salary": { "min": 211400, "max": 290600, "currency": "USD", "interval": "1 YEAR", "summary": "$211.4K – $290.6K • Offers Equity" },
  "postedAt": "2026-04-07T17:12:35.753Z",
  "url": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245",
  "applyUrl": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245/application",
  "isNew": null,
  "via": "input"
}

A Greenhouse row has the same keys. For GitLab, salary, employmentType and country were null, because that board doesn't publish them.

That curl run (six boards, title keywords, maxJobsPerCompany: 50) read 229 postings and delivered the 57 matching titles: 19 GitLab (Greenhouse), 14 Ramp (Ashby), 14 Spotify (Lever), 5 Hugging Face (Workable), 4 Ubisoft (SmartRecruiters) and 1 bunq (Recruitee). It took about 23 seconds locally.

The domain-detection test (stripe.com, ramp.com, huggingface.co, ostrata.io, qonto.com) found four boards. Hugging Face (Workable) and Qonto (Lever) came from links on their careers pages (via: "careers_page"), and Stripe (Greenhouse) and Ramp (Ashby) from probing the APIs (via: "api_probe"). ostrata.io has no public board: the run checked /, /careers and /jobs, then reported no_job_board_found and charged nothing.

Use it from an AI agent (MCP)

{
  "mcpServers": {
    "ats-jobs": {
      "url": "https://mcp.apify.com?tools=ostrata/ats-jobs-api"
    }
  }
}

Sign in with OAuth on first use, or send Authorization: Bearer <APIFY_TOKEN>. Then ask your assistant something like "List open engineering roles in Paris or remote at stripe.com, ramp.com and qonto.com". The agent passes the domains, and the Actor finds each company's ATS on its own.

Pricing

Pay-per-event, as listed on the Apify Store on 19 Oct 2026:

$0.003 per job returned in the dataset ($3 per 1,000).
Not charged: jobs removed by your filters, jobs already seen in only-new mode, boards with no jobs, companies with no board found, errors.
Standard Apify start event: $0.00005 per run.

The six-board example above cost 57 × $0.003 = $0.171. A daily only-new run on a stable list costs only the new postings, often a few cents. maxTotalChargeUsd stops the run cleanly at your budget. In our budget test, a cap that covered 10 jobs delivered exactly 10.

Honest limits

Six ATS only. Workday, Taleo, Teamtailor, Welcome to the Jungle and in-house career sites aren't covered yet.
Company names: Lever and Ashby don't expose the company's display name, so company is the board slug (ramp, spotify).
Salary appears only when the ATS publishes it: mostly Ashby, some Lever and Recruitee boards.
Large boards: maxJobsPerCompany (default 500) caps what's read per board. Stripe's Greenhouse board hit that cap in one of our tests, so raise it if you need everything.
SmartRecruiters descriptions need one extra API call per job. Turn includeDescription off for very large boards.
Privacy: recruiter and hiring-manager names and contact emails, which some APIs include, are dropped.

Written by the Ostrata team (ostrata.io).

How to bulk-verify EU VAT numbers and companies (VIES, LEI, SIREN) with one API call

Ostrata — Mon, 19 Oct 2026 12:27:57 +0000

If you onboard B2B customers, suppliers or marketplace sellers in Europe, sooner or later someone asks: is this company real, active, and is its VAT number valid?

Answering that by hand means opening several tabs. You check the VAT number in the European Commission's VIES service, look the company up in the national register (Sirene/RNE in France, Brønnøysund in Norway, PRH in Finland, ARES in Czechia), search GLEIF for an LEI, and for French companies look through BODACC for insolvency notices. That's fine for one company. For a CSV of 2,000 it isn't.

This tutorial shows how to do the whole check in bulk with the EU Company Verification (KYB): VIES VAT, LEI, SIREN Actor on Apify, which our team at Ostrata built and maintains. You send a list of strings and get back one record per company with a verdict and the machine-readable reasons behind it. At the end there's a second Actor for when you only have a website, not a company number.

What you can put in

The input is a list. Each line can be:

a company name (Doctolib), searched in the default country's register
a French SIREN or SIRET (552 120 222), a Norwegian org number, a Finnish Y-tunnus or a Czech IČO
an EU VAT number (FR40303265045, DE811569869, IE6388047V)
an LEI (969500BPSLCSC039UV67)
any of the above with a country prefix to force the country: NO: Equinor, CZ: Alza

Identifiers are detected automatically. The other input fields are optional:

Field	Default	What it does
`defaultCountry`	`FR`	Register used for bare names: `FR`, `NO`, `FI`, `CZ`, or `ANY` (GLEIF LEI index)
`checkVat`	`true`	Live VIES check (the VAT number is derived from the SIREN for France)
`checkLei`	`true`	GLEIF LEI lookup and status
`checkInsolvency`	`true`	BODACC collective proceedings (last 3 years) for France, registry flags elsewhere
`maxCandidatesPerQuery`	`1`	How many matches to return per name search
`minNameScore`	`"0.5"`	Drop weaker name matches; below 0.85 the verdict becomes `review`
`excludeSoleProprietors`	`true`	Name searches return legal entities only
`includeRaw`	`false`	Attach the raw registry payload
`concurrency`	`3`	Parallel queries (each upstream API is also rate-limited per host)

Step 1: Run it from the Console

Open apify.com/ostrata/eu-company-check and click Try for free. A free Apify account works.
Paste your list into Companies to check, one per line.
Leave the defaults on, or switch off the LEI check if you don't need it.
Click Start. Results appear in the Output tab and can be exported as JSON, CSV or Excel.

Step 2: Call it with curl

The run-sync-get-dataset-items endpoint runs the Actor and returns the dataset in one HTTP call. maxTotalChargeUsd puts a hard cap on what the run may charge:

curl -s -X POST \
  "https://api.apify.com/v2/acts/ostrata~eu-company-check/run-sync-get-dataset-items?maxTotalChargeUsd=1" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "companies": ["FR40303265045", "Blablacar", "440471100", "NO: Equinor", "IE6388047V"],
    "defaultCountry": "FR",
    "checkVat": true,
    "checkLei": true,
    "checkInsolvency": true
  }'

Synchronous runs time out after 300 seconds. For thousands of rows, start an asynchronous run instead (POST /v2/acts/ostrata~eu-company-check/runs) and read the dataset when it finishes, or use a client library as below.

Step 3: JavaScript (apify-client)

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('ostrata/eu-company-check').call(
  {
    companies: ['FR40303265045', 'Doctolib', 'NO: 923609016', 'CZ27082440'],
    defaultCountry: 'FR',
    checkLei: false, // faster if you don't need LEIs
  },
  { maxTotalChargeUsd: 2 }, // stop before spending more than $2
);

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const c of items) {
  console.log(c.query, c.verdict, c.legalName, c.vatValid, c.reasons.join(','));
}

Step 4: Python (apify-client 3.x)

import os
from decimal import Decimal
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("ostrata/eu-company-check").call(
    run_input={
        "companies": ["DE811569869", "IT00743110157", "ES: Inditex"],
        "defaultCountry": "ANY",
    },
    max_total_charge_usd=Decimal("1"),
)

needs_review = [
    row for row in client.dataset(run.default_dataset_id).iterate_items()
    if row["verdict"] != "verified"
]
print(needs_review)

Filtering on verdict != "verified" is the useful pattern: your team only looks at the rows that need a human.

What comes back

Here is a trimmed record from one of our own test runs (19 Oct 2026), for the VAT number FR40303265045:

{
  "query": "FR40303265045",
  "queryType": "vat",
  "verdict": "verified",
  "reasons": ["registry_status_active", "vat_valid_in_vies", "lei_issued"],
  "warnings": [],
  "legalName": "SODIMAS",
  "country": "FR",
  "registrationNumber": "303265045",
  "registrationNumberType": "SIREN",
  "registryStatus": "active",
  "vatNumber": "FR40303265045",
  "vatValid": true,
  "lei": "969500GZTMR1IRVURM23",
  "insolvencyFlag": false,
  "company": {
    "legalForm": "SA à conseil d’administration",
    "registrationDate": "1975-08-21",
    "address": { "postalCode": "26600", "city": "PONT-DE-L'ISERE", "country": "FR" },
    "activity": { "code": "28.22Z", "scheme": "NAF rev.2" },
    "employees": "250-499"
  },
  "vat": { "valid": true, "name": "SA SODIMAS", "source": "VIES VAT number validation (European Commission)" }
}

Every record also carries a sources array naming each register used and its licence.

The same test runs gave these verdicts across a mixed list:

Input	Verdict	Legal name	Why
`552 120 222`	verified	SOCIETE GENERALE	active in Sirene, VAT valid in VIES, LEI issued
`Blablacar`	verified	COMUTO	name match 1.0 (trade name), LEI issued
`440471100`	inactive	LB	ceased in the register, VAT not valid, liquidation notice in BODACC
`NO: Equinor`	verified	EQUINOR ASA	active in Brønnøysund (Norway is not in VIES, so no VAT check)
`CZ27082440`	verified	Alza.cz a.s.	active in ARES, VAT valid in VIES
`IE6388047V`	verified	GOOGLE IRELAND LIMITED	VAT valid in VIES (no Irish register adapter), LEI issued
`ES: Inditex`	review	INDUSTRIA DE DISEÑO TEXTIL, S.A.	GLEIF entity status not confirmed
`zzqx nonexistent company 4821`	not_found	–	not charged

The Blablacar row is a good example of why the record has warnings. VIES answered MS_MAX_CONCURRENT_REQ (the French VIES node was busy), so the record came back with vatValid: null and the warning vat_check_unavailable:MS_MAX_CONCURRENT_REQ. A busy VIES node is never reported as an invalid VAT number.

You only have a website? Use Website to Company

Lead lists and signup forms often give you a domain, not a company number. The companion Actor Website to Company: Impressum & Mentions Légales Scraper reads a site's legal notice (mentions légales, Impressum, imprint), extracts the SIREN, VAT number, trade-register number or LEI, and then runs the same verification.

curl -s -X POST \
  "https://api.apify.com/v2/acts/ostrata~website-company-check/run-sync-get-dataset-items?maxTotalChargeUsd=1" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"websites": ["qonto.com", "zalando.de", "alan.com"], "verify": true}'

In our tests, qonto.com came back as QONTO, SIREN 819489626, VAT FR10819489626, valid in VIES. zalando.de returned VAT DE260543043 (valid) and the trade-register entry HRB 158855 B at Amtsgericht Charlottenburg Berlin, but legalName: null, because German VIES never returns names. Several sites (doctolib.fr, malt.fr, blablacar.fr, personio.de) were reported as blocked by bot protection and were not charged: the Actor makes plain HTTP requests, respects robots.txt and does not try to get around protection.

Other input fields: verify (off = identification only), checkVat, checkInsolvency, checkLei (off by default because GLEIF allows 60 requests/minute), excludeSoleProprietors, maxPagesPerSite (default 4) and concurrency.

Use it from an AI agent (MCP)

Both Actors work as tools in any MCP client (Claude, Cursor, VS Code and others) through Apify's hosted MCP server:

{
  "mcpServers": {
    "eu-company-check": {
      "url": "https://mcp.apify.com?tools=ostrata/eu-company-check,ostrata/website-company-check"
    }
  }
}

On first connection your client opens an Apify sign-in (OAuth). You can also pass Authorization: Bearer <APIFY_TOKEN> as a header. Then ask something like: "Check whether FR40303265045 and NO: Equinor are active companies with valid VAT numbers." The run is billed to the Apify account that's connected.

Pricing

Both Actors are pay-per-event, prices as listed on the Apify Store on 19 Oct 2026:

EU Company Verification (KYB): $0.005 per company found (verdict verified, review or inactive), so $5 per 1,000. not_found, invalid_input and error rows are free.
Website to Company: $0.004 per website where an identifier is found, plus $0.005 when that company is verified. Blocked sites, sites with no identifier and errors are free.
Both have the standard Apify start event of $0.00005 per run.

Run as one list, the eight inputs in the table above would cost 7 × $0.005 = $0.035, because the not-found row is free.

Honest limits

Full register adapters exist for France, Norway, Finland and Czechia. Elsewhere, VAT numbers are checked in VIES and names are searched in GLEIF, which only covers companies that hold an LEI.
Germany, Spain and some other member states never return a name or address through VIES, so you get vatValid but legalName: null.
VIES nodes go down or throttle. The Actor retries, then returns vatValid: null with a warning instead of a false "invalid".
Website to Company does not render JavaScript, so pages built only client-side are not read.
Neither Actor returns people's data: no directors, shareholders, emails or phone numbers. Sole proprietors are excluded by default.
Results reflect the sources at query time. It is a data tool, not legal advice.

If your use case needs another country register, tell us in the Actor's Issues tab on Apify. UK, Germany and the Netherlands are the next ones we're looking at.

Written by the Ostrata team (ostrata.io).