---
title: "11 ATS Platforms with Public Job Posting APIs [2026]"
description: "A practical guide to the public ATS APIs that actually work for pulling jobs into a job board. Covers Greenhouse, Lever, Ashby, Workable, Recruitee, Personio, SmartRecruiters, Pinpoint, Gem, Polymer, and Teamtailor, with exact endpoints, undocumented feeds that also work, and what to do when an ATS has no public feed."
image: "/site/images/blog/covers/176390be-56d6-4bfd-9c0e-1d64eed62ba0.webp"
publishedAt: 2026-04-03
updatedAt: 2026-10-29
status: "published"
categories:
  - Technology
tags:
  - "ATS API"
  - "job feeds"
  - "job aggregation"
  - "public API"
  - "job board data"
  - "applicant tracking system"
cta:
  sidebar:
    headline: "Fill your board from ATS feeds with AI aggregation"
    description: "Cavuno scrapes authorized ATS sources, AI-tags skills, deduplicates, and expires jobs so you skip per-API plumbing."
  footer:
    headline: "Import ATS jobs, then charge employers on your domain"
    description: "Cavuno pulls public ATS feeds onto a white-label board with Stripe checkout and no revenue share."
faqs:
  - question: "What is an ATS?"
    answer: "ATS stands for applicant tracking system. It is the software employers use to publish jobs, collect applications, and manage hiring workflows. Common ATS platforms include Greenhouse, Lever, Ashby, Workable, Recruitee, and Personio."
  - question: "Which ATS platforms have public job posting APIs or feeds?"
    answer: "The vendor-documented options that returned published jobs without employer credentials in our tests are Greenhouse, Lever, Ashby, Workable, Recruitee, Personio, SmartRecruiters, Pinpoint, Gem, Polymer, and Teamtailor. Most return published jobs as JSON. Personio publishes an XML feed and Teamtailor an RSS feed. Breezy HR, BambooHR, Rippling, Workday, and Manatal career pages also serve published jobs without credentials, but through endpoints their vendors do not document for this use."
  - question: "What is the easiest public ATS API for a job board?"
    answer: "Greenhouse is usually the easiest place to start because the endpoint is clean, widely used, and returns the fields most job boards need. Lever is also straightforward and adds useful filtering parameters."
  - question: "Does Workday have a public job posting API?"
    answer: "Not a documented one. Workday career sites load jobs from an internal JSON endpoint that answers POST requests without credentials, and many scrapers use it, but Workday does not document or support it for third parties. Treat it as undocumented: it can change without notice, and detail pages vary by tenant."
  - question: "Which ATS platforms do not offer an open job feed?"
    answer: "Comeet, JOIN, and Teamtailor's JSON API all offer job APIs, but each needs a token or key that the employer creates and shares with you. JazzHR, Zoho Recruit, Dover, Homerun, and iCIMS offer authenticated APIs or approved-partner feeds rather than an open feed."
  - question: "What should I do if an ATS does not have a public API?"
    answer: "Your realistic options are to use a public XML feed if the ATS offers one, extract jobs from the employer's career page, buy coverage from an aggregator, or use a platform like Cavuno that already handles sourcing, deduplication, expiry, and indexing for you."
  - question: "Should I build direct ATS integrations for a job board?"
    answer: "Usually only if your board depends on a small number of ATS platforms and you want tight control over the source data. Most job board operators care more about getting relevant jobs onto the board quickly and keeping them fresh than about maintaining source-by-source integrations."
---

If you are building a job board, relevant jobs are the product. Public ATS feeds are one practical way to retrieve published vacancies without private recruiting credentials. Some feeds still require employer configuration: Personio’s XML feed must be activated before it is available. Public access also differs from permission to redistribute listings; check the source’s terms or agreement.

This guide covers the public ATS sources that are actually useful for a job board, the exact endpoints they expose, and what to do when an ATS does not offer one.

## What is an ATS, and what counts as a public job posting API?

An **applicant tracking system (ATS)** is the software employers use to publish roles, collect applications, and manage the hiring process. Greenhouse, Lever, Ashby, Workable, Recruitee, Personio, SmartRecruiters, Pinpoint, Gem, Polymer, and Teamtailor are all ATS platforms. If you want the broader distinction between ATS tools and [job board software](/blog/what-is-job-board-software), start there.

For a job board, the part that matters is the public careers layer. A public job posting API is any documented endpoint or feed that lets you retrieve published jobs without asking each employer for API credentials first. In practice, that usually means one of two things:

- a public JSON API
- a public XML job feed

The useful fields are the same either way: title, location, description, department, employment type, updated date, source URL, and apply URL. That is enough to power a board, even if you still need to normalize titles, clean up locations, deduplicate listings, and expire jobs when they disappear from the source.

## How job boards actually use public ATS APIs

Most job boards do not build a deep integration into each ATS. They pull the published jobs, store them in their own schema, add their own search and filtering, and then send candidates to the original apply URL.

The basic workflow looks like this:

1. Fetch published jobs from the public ATS endpoint or feed.
2. Normalize fields like location, workplace type, salary, department, and remote status.
3. Deduplicate jobs by source URL, external job ID, or a combination of both.
4. Re-sync on a schedule so new jobs appear quickly and closed jobs disappear.
5. Display the jobs on your own board with your own search, filters, SEO pages, and monetization.

Keep the provider job ID, source board and original application URL. Expire missing records only after a complete, successful snapshot, including every required page; a failed request or partial response must not close existing jobs. Treat absent salary and location fields as unknown. On October 29, 2026, we confirmed every endpoint in this guide still returns jobs for a live employer. The example responses for Greenhouse, Lever, Ashby, Workable, Recruitee and Personio were captured on April 3, 2026; the others come from the October 29 test.



That is why public ATS APIs are valuable for job boards. They remove the hardest part of direct ATS work, which is authentication and customer-by-customer setup. They do **not** remove the rest of the operating work. You still need to handle freshness, deduplication, taxonomy cleanup, and source quality. If you want the broader picture, our guides on [job feeds](/blog/job-feeds), [job scraping](/blog/job-scraping), [job wrapping](/blog/job-wrapping), and [job board aggregators](/blog/job-board-aggregator) cover the other ways boards get jobs onto the site.

## 11 ATS platforms with free public job posting APIs or feeds

These are the eleven options that each vendor describes in its own developer docs or help centre, linked in its section below. All eleven returned published jobs without employer credentials when we tested them on October 29, 2026.

| Platform | Public endpoint | Format | What you get | Main limitation |
| --- | --- | --- | --- | --- |
| Greenhouse | `GET https://boards-api.greenhouse.io/v1/boards/{board_token}/jobs?content=true` | JSON | Published jobs, descriptions, departments, offices, apply URLs, updated timestamps | No native search or filtering |
| Lever | `GET https://api.lever.co/v0/postings/{site}?mode=json` | JSON | Published jobs, categories, hosted URLs, apply URLs, optional salary fields | You still need to build your own search layer |
| Ashby | `GET https://api.ashbyhq.com/posting-api/job-board/{job_board_name}?includeCompensation=true` | JSON | Published jobs plus structured compensation summaries | No built-in search or filtering on the public feed |
| Workable | `GET https://www.workable.com/api/accounts/{account_subdomain}?details=true` | JSON | Published jobs plus job details from the public careers layer | Companion locations and departments come from separate endpoints |
| Recruitee | `GET https://{company}.recruitee.com/api/offers/` | JSON | Published jobs, `careers_url`, `careers_apply_url`, department and tag filters | Lighter metadata than Greenhouse or Ashby |
| Personio | `GET https://{company}.jobs.personio.de/xml?language=en` | XML | Published jobs, office, department, employment type, description blocks | XML feed, not JSON |
| SmartRecruiters | `GET https://api.smartrecruiters.com/v1/companies/{companyIdentifier}/postings` | JSON | Published jobs, structured location, employment type, release date; description and apply URL per posting | Full description needs a second call per job |
| Pinpoint | `GET https://{company}.pinpointhq.com/postings.json` | JSON | Published jobs, HTML description, structured salary, workplace type, department | No posted date |
| Gem | `GET https://api.gem.com/job_board/v0/{board}/job_posts/` | JSON | Published jobs, HTML and plain-text content, first-published and updated dates, departments, offices | No salary field |
| Polymer | `GET https://api.polymer.co/v1/hire/organizations/{slug}/jobs` | JSON | Published jobs, location, remote rules, published date, salary text | Description comes from a per-job call |
| Teamtailor | `GET https://{company}.teamtailor.com/jobs.rss` | RSS | Published jobs, description, publication date, remote status, locations, department | RSS, 100 jobs per page by default |

### Greenhouse

Greenhouse is usually the easiest public ATS API to start with. The response includes the fields most job boards need: title, location, departments, offices, description content, updated timestamps, and apply URLs.

```bash
curl "https://boards-api.greenhouse.io/v1/boards/acme/jobs?content=true"
```

Replace `acme` with the company's Greenhouse board token.

Example live response from Stripe on April 3, 2026:

```json
{
  "id": 7546284,
  "title": "Account Executive, AI Sales",
  "location": {
    "name": "San Francisco, CA"
  },
  "absolute_url": "https://stripe.com/jobs/search?gh_jid=7546284",
  "updated_at": "2026-04-01T11:46:05-04:00",
  "company_name": "Stripe"
}
```

### Lever

Lever is one of the better public JSON APIs if you want basic filtering at the source. It supports parameters like `team`, `department`, `location`, `commitment`, `level`, `skip`, and `limit`.

```bash
curl "https://api.lever.co/v0/postings/lever?mode=json&limit=20"
```

Replace `lever` with the company's Lever site name.

For an EU-hosted Lever board, use `https://api.eu.lever.co/v0/postings/{site}?mode=json` and the corresponding `jobs.eu.lever.co` career site. Find the site name in the employer’s career URL. Follow `skip` and `limit` pagination rather than treating the first 20 results as a complete snapshot. See the [official Lever Postings API](https://github.com/lever/postings-api/blob/master/README.md).



Example live response from Dun & Bradstreet on April 3, 2026:

```json
{
  "text": "Account Executive II, SLED (R-18831)",
  "categories": {
    "commitment": "Employee: Full Time",
    "location": "Remote - United States",
    "team": "Government Relations"
  },
  "hostedUrl": "https://jobs.lever.co/dnb/6590549e-d893-4e0e-8934-dda77ef05223",
  "applyUrl": "https://jobs.lever.co/dnb/6590549e-d893-4e0e-8934-dda77ef05223/apply",
  "salaryRange": {
    "currency": "USD",
    "min": 123100,
    "max": 206800
  }
}
```

### Ashby

Ashby is the public ATS feed with the cleanest compensation support. If salary matters on your board, `includeCompensation=true` is the parameter to care about.

```bash
curl "https://api.ashbyhq.com/posting-api/job-board/ashby?includeCompensation=true"
```

Replace `ashby` with the company's Ashby job board name.

Before adding Ashby records to search or category listings, exclude records with `isListed: false`: those are intended for direct-link access only. Preserve `jobUrl`, `applyUrl` and geographic eligibility separately from `isRemote`. See the [Ashby public API contract](https://developers.ashbyhq.com/docs/public-job-posting-api).



Example live response from Ashby on April 3, 2026:

```json
{
  "id": "145ff46b-1441-4773-bcd3-c8c90baa598a",
  "title": "Engineer Who Can Design, Americas",
  "location": "Remote - North to South America",
  "department": "Engineering",
  "workplaceType": "Remote",
  "jobUrl": "https://jobs.ashbyhq.com/ashby/145ff46b-1441-4773-bcd3-c8c90baa598a",
  "applyUrl": "https://jobs.ashbyhq.com/ashby/145ff46b-1441-4773-bcd3-c8c90baa598a/application",
  "compensation": {
    "compensationTierSummary": "$190K – $255K • Offers Equity • Multiple Ranges",
    "scrapeableCompensationSalarySummary": "$190K - $255K"
  }
}
```

### Workable

Workable's public careers layer is split across a few endpoints. The main one returns the public account and job data, and the companion endpoints return locations and departments.

```bash
curl -L "https://www.workable.com/api/accounts/acme?details=true"
curl -L "https://www.workable.com/api/accounts/acme/locations"
curl -L "https://www.workable.com/api/accounts/acme/departments"
```

Replace `acme` with the employer's Workable account subdomain.

Example live response from Epignosis on April 3, 2026:

```json
{
  "title": "Customer Onboarding Specialist",
  "shortcode": "072EA3CA72",
  "url": "https://apply.workable.com/j/072EA3CA72",
  "location": null,
  "department": "Customer Success",
  "employment_type": "Full-time"
}
```

### Recruitee

Recruitee exposes a public offers endpoint on each employer subdomain. It is simple to call and works well when you just want published jobs plus the public careers and apply URLs.

```bash
curl "https://acme.recruitee.com/api/offers/"
```

Replace `acme` with the employer's Recruitee subdomain.

Example live response from Adamsmithinternational1 on April 3, 2026:

```json
{
  "id": 2534691,
  "title": "Team Leader - HEROS 2 Programme",
  "location": "London, England, United Kingdom",
  "department": "Project Positions",
  "careers_url": "https://adamsmithinternational1.recruitee.com/o/team-leader-heros-2-programme",
  "careers_apply_url": "https://adamsmithinternational1.recruitee.com/o/team-leader-heros-2-programme/c/new",
  "employment_type_code": "contract",
  "remote": false
}
```

### Personio

Personio is the main XML-based public source worth knowing about. If your import pipeline already supports XML, it is straightforward to add.

```bash
curl "https://acme.jobs.personio.de/xml?language=en"
```

Replace `acme` with the employer's Personio career-site subdomain. Some accounts use `.com` instead of `.de`, so check the live career-site hostname before hardcoding it.

Example live response from Personio on April 3, 2026:

```xml
<position>
  <id>1834171</id>
  <subcompany>Personio SE &amp; Co. KG</subcompany>
  <office>Munich</office>
  <department>Product and Tech</department>
  <recruitingCategory>Engineering</recruitingCategory>
  <name>Staff Software Engineer, Data Platform</name>
  <employmentType>permanent</employmentType>
</position>
```

### SmartRecruiters

SmartRecruiters' Posting API serves every job an employer has made public on its SmartRecruiters career site. The list endpoint returns titles, structured locations, employment type and release dates, paginated with `limit` and `offset`.

```bash
curl "https://api.smartrecruiters.com/v1/companies/acme/postings?limit=100"
```

Replace `acme` with the company identifier from the employer's SmartRecruiters career URL. For the description, apply URL and job ad sections, fetch each posting's `ref` URL.

The [Posting API docs](https://developers.smartrecruiters.com/docs/posting-api) say it supports API key and OAuth 2.0 authentication; credentials matter for internal postings. Public postings answered our calls without a key, but if you plan to rely on this source at volume, check the current terms with SmartRecruiters.

Example live response from Grab on October 29, 2026:

```json
{
  "id": "744000158582629",
  "name": "Country Controller, Associate",
  "releasedDate": "2026-10-29T17:57:26.077Z",
  "location": {
    "city": "Jakarta",
    "country": "id",
    "remote": false,
    "hybrid": false,
    "fullLocation": "Jakarta, , Indonesia"
  },
  "typeOfEmployment": {
    "id": "permanent",
    "label": "Full-time"
  },
  "ref": "https://api.smartrecruiters.com/v1/companies/Grab/postings/744000158582629"
}
```

### Pinpoint

Pinpoint publishes a JSON endpoint on every career site, and it has the richest salary data of any feed in this guide: minimum, maximum, currency, frequency, and whether the employer chose to show it.

```bash
curl "https://acme.pinpointhq.com/postings.json"
```

Replace `acme` with the employer's Pinpoint subdomain. The [Pinpoint jobs JSON docs](https://developers.pinpointhq.com/docs/jobs-json-endpoint) describe filters such as department and location, and note that `postings.json` replaces the older `jobs.json`. Respect `compensation_visible`: if it is `false`, keep the salary off your board.

Example live response from Stratom on October 29, 2026:

```json
{
  "id": "433307",
  "title": "Sr. Mechanical Engineer",
  "url": "https://stratom.pinpointhq.com/en/postings/06a8f606-dbab-46de-920c-5ce175e59bb9",
  "workplace_type": "onsite",
  "employment_type": "full_time",
  "compensation_minimum": 120000.0,
  "compensation_maximum": 180000.0,
  "compensation_currency": "USD",
  "compensation_frequency": "year",
  "compensation_visible": true,
  "location": {
    "name": "Louisville, CO",
    "city": "Louisville",
    "province": "CO"
  }
}
```

### Gem

Gem's Job Board API will look familiar if you already support Greenhouse: the response shape is close, with content in both HTML and plain text, plus first-published and updated timestamps.

```bash
curl "https://api.gem.com/job_board/v0/acme/job_posts/"
```

Replace `acme` with the employer's Gem job board path, the part after `jobs.gem.com/` in their careers URL. See [Gem's Job Board API guide](https://help.gem.com/databases/gem-help-center/the-job-board-api).

Example live response from Dragonfly on October 29, 2026:

```json
{
  "id": "4621552004",
  "title": "Software Engineer - Dragonfly Portfolio",
  "location": {
    "name": "San Francisco, United States"
  },
  "location_type": "hybrid",
  "employment_type": "full_time",
  "departments": [{ "id": "4061506004", "name": "Portfolio" }],
  "first_published_at": "2022-08-09T20:19:43.000Z",
  "updated_at": "2026-10-15T20:02:47.278Z",
  "absolute_url": "https://jobs.gem.com/dragonfly-careers/4621552004"
}
```

### Polymer

Polymer documents its Public API as unauthenticated and intended for job board integrations. The list endpoint is paginated (`meta.next_page`) and carries remote-work rules, such as required countries of residency, that most feeds leave out.

```bash
curl "https://api.polymer.co/v1/hire/organizations/acme/jobs"
curl "https://api.polymer.co/v1/hire/organizations/acme/jobs/36077"
```

Replace `acme` with the employer's Polymer slug, from `jobs.polymer.co/{slug}`. The list omits the description; fetch each job by ID to get it. The [Polymer developer docs](https://developer.polymer.co/) note that requests are rate-limited, so back off on a `429` response.

Example live response from Fleet Robotics on October 29, 2026:

```json
{
  "id": 36077,
  "title": "Autonomy Engineer",
  "display_location": "Charlestown, MA",
  "remoteness_pretty": "Hybrid",
  "kind_pretty": "Full-time",
  "salary_pretty": null,
  "published_at": "2025-09-23T18:35:14.139Z",
  "job_post_url": "https://jobs.polymer.co/fleet-robotics/36077"
}
```

### Teamtailor

Teamtailor career sites publish an RSS feed of open jobs. The [Teamtailor RSS guide](https://support.teamtailor.com/en/articles/11171756-rss-feed-how-to-guide) states that everything in it is publicly available: title, description, publication date, job URL, remote status, a global ID, locations, department and role.

```bash
curl "https://acme.teamtailor.com/jobs.rss?per_page=200"
```

Replace `acme` with the employer's Teamtailor subdomain, or use their custom careers domain followed by `/jobs.rss`. The feed returns 100 jobs by default; use `per_page` and `offset` to page through larger employers.

Example live response from Robot.com on October 29, 2026:

```xml
<item>
  <title>Robot Operations Technician</title>
  <pubDate>Mon, 28 Sep 2026 15:15:31 -0500</pubDate>
  <link>https://careers.robot.com/jobs/708794-robot-operations-technician</link>
  <remoteStatus>onsite</remoteStatus>
  <guid>b6b16751-7fac-4ae0-9ae3-8d09bf092ba4</guid>
  <tt:locations>
    <tt:location>
      <tt:city>Las Vegas</tt:city>
      <tt:country>United States</tt:country>
    </tt:location>
  </tt:locations>
</item>
```

Teamtailor also has a JSON API with a "public" key scope, but the employer has to create that key and share it with you.

## Undocumented endpoints that also work

Five more ATS platforms serve published jobs as JSON without credentials, but none of their vendors document these endpoints for this use. They are the same requests the vendor's own career pages make in the browser. All five returned live jobs on October 29, 2026. Use them knowing they can change or disappear without notice, and keep a fallback such as [job wrapping](/blog/job-wrapping) for employers that matter to your board.

| Platform | Endpoint | What you get | Watch out for |
| --- | --- | --- | --- |
| Breezy HR | `GET https://{company}.breezy.hr/json` | Title, URL, published date, employment type, location, salary text | No description in the list |
| BambooHR | `GET https://{company}.bamboohr.com/careers/list` | Title, department, location, remote flag | Description and pay need `/careers/{id}/detail` per job |
| Rippling | `GET https://api.rippling.com/platform/api/ats/v1/board/{slug}/jobs` | Title, department, location, job URL | Thin list; no description or dates |
| Workday | `POST https://{tenant}.wd{N}.myworkdayjobs.com/wday/cxs/{tenant}/{site}/jobs` | Title, location text, relative posted date, job path | Needs a JSON body with `limit` (20 at most) and `offset`; relative dates such as "Posted Today"; behaviour varies by tenant |
| Manatal | `GET https://www.careers-page.com/api/v1.0/c/{slug}/jobs/` | Title, description, location, salary visibility; paginated | Rate-limited: answers `429` if you call too fast |

Workday is the one most job boards ask about, because so many large employers use it. The request needs the tenant, the data-centre number (`wd1`, `wd5` and so on) and the career site name, all visible in the employer's careers URL:

```bash
curl -X POST "https://acme.wd5.myworkdayjobs.com/wday/cxs/acme/External/jobs" \
  -H "Content-Type: application/json" \
  -d '{"limit": 20, "offset": 0, "searchText": "", "appliedFacets": {}}'
```

Page with `offset`: Workday rejects a `limit` above 20 with a `400`.

Example live response from Globus Medical on October 29, 2026:

```json
{
  "total": 343,
  "jobPostings": [
    {
      "title": "Inventory Control Clerk, 2nd Shift",
      "externalPath": "/job/Eagleville-PA/Inventory-Control-Clerk--2nd-Shift_JR108078-1",
      "locationsText": "Eagleville, PA",
      "postedOn": "Posted Today"
    }
  ]
}
```

## ATS platforms without an open feed

Many ATS platforms do have job APIs, but they need a token or key from the employer, or they are reserved for approved partners. You can still use them when an employer agrees to share access, but you cannot build coverage from them on your own.

| Platform | What exists | What you need |
| --- | --- | --- |
| Comeet | Careers API (`/careers-api/2.0/company/{uid}/positions`) | A company token from the employer |
| JOIN | Jobs API v2 | The employer's API token |
| Teamtailor (JSON) | JSON API with a public key scope | A key the employer creates |
| JazzHR | Account API | The employer's API key |
| Zoho Recruit | REST API | OAuth 2.0 credentials |
| Dover | Jobs API | The employer's API key |
| Homerun | Developer API, plus job XML feeds | An API key from the employer, or a feed link they generate |
| iCIMS | Standard XML feed for job boards | Approval from iCIMS and OAuth 2.0 |

For these, career-page extraction is usually the practical route, or a platform that already sources from them.

## What to do when an ATS does not have a public API

Most boards do not live on public ATS APIs alone. Once you move beyond the sources above, you usually combine four different methods:

- public ATS APIs like Greenhouse, Lever, or Ashby
- public XML feeds like Personio or feed-based Recruitee setups
- career-page extraction through [job wrapping](/blog/job-wrapping) or [job scraping](/blog/job-scraping)
- pre-built job data sources and [job feeds](/blog/job-feeds)

That is also the point where most operators should stop asking, "Can we integrate one more ATS ourselves?" and start asking, "Do we really want to own this pipeline?"

If your actual goal is to get relevant jobs onto your board, keep them fresh, deduplicate them, and get them indexed, Cavuno is the simpler path. Cavuno already pulls from public ATS APIs, career pages, feeds, and other public job sources, then handles the parts most teams underestimate:

- deduplication by source URL
- expiry when jobs disappear
- company enrichment
- search-ready normalization
- moderated imports when you want editorial control

That is what [Backfill](/docs/backfill/what-is-backfill) is for. You define the kinds of jobs you want, Cavuno imports matching jobs onto the board, and you can review them through [job moderation](/docs/managing-jobs/job-moderation) if you want tighter control. Once they are live, you can run the board on your own [custom domain](/docs/board-setup/connect-custom-domain) and speed up discovery with the [Google Indexing API](/docs/job-board-seo/indexing-api).

If you are building an HR tech product whose value is the integration itself, direct ATS work makes sense. If you are building a job board, the better question is usually how to get reliable job supply without turning source maintenance into your product.

## Which public ATS API is best for a job board?

The better question is not which API is "best" in the abstract. It is which ATSs show up in the kinds of companies your board cares about.

- **Greenhouse** is the highest-leverage place to start for startup, software, and venture-backed company coverage. If your board targets tech, product, engineering, or venture-backed hiring, Greenhouse will show up constantly.
- **Lever** is common in tech as well, especially among growth-stage companies and teams that want a polished hosted careers experience. It is a good second source after Greenhouse for startup-heavy niches.
- **Ashby** tends to show up in newer, high-growth startups, especially companies that care about modern recruiting workflows and salary transparency. If your niche overlaps with startup hiring or tech-forward employers, it is worth supporting.
- **Workable** appears much more often outside the classic venture-backed startup world. It is common among SMBs, agencies, and operational teams that want an easy careers setup without a heavyweight recruiting stack.
- **Recruitee** is common among SMB and mid-market teams, particularly in Europe. If your board skews toward smaller employers or international hiring outside the US venture ecosystem, it is a useful source.
- **Personio** matters most when your target employers are in Europe, especially DACH markets. It is less about broad global coverage and more about reaching the companies that already run hiring through Personio.
- **SmartRecruiters** is common among large and enterprise employers worldwide, so it adds volume that the startup-focused feeds miss.
- **Pinpoint** is the best source when salary data matters: it is structured, and it tells you whether the employer wants it shown.
- **Gem** and **Polymer** show up mostly among startups and venture-backed companies. If you already support Greenhouse, Gem is the quickest one to add.
- **Teamtailor** is widespread among European employers, particularly in the Nordics. Its RSS feed is easy to add if your pipeline already reads XML.

For most operators, that is enough to prove the concept quickly. After that, the problem stops being "which public ATS has an API?" and becomes "how do we keep jobs clean, current, and useful at scale?" That is the part that determines whether a board feels empty and stale or alive and worth returning to.
