# Company Job Board Finder — Domain to ATS & Careers (`dev_web_col/ats-finder`) Actor

Find any company's job board from its domain: which ATS it runs on, the board URL and how many roles are open. Greenhouse, Lever, Ashby and 3 more.

- **URL**: https://apify.com/dev\_web\_col/ats-finder.md
- **Developed by:** [Diseño Web de Colombia](https://apify.com/dev_web_col) (community)
- **Categories:** Jobs, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 company checkeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Company Job Board Finder — Domain to ATS & Careers

**Give it a domain. Get the company's job board, which ATS runs it, and how many roles are open right now.**

```json
{ "domains": ["ramp.com", "figma.com", "gitlab.com"] }
```

Real output from that run:

```
ramp.com     ashby:ramp           124 open roles   jobs.ashbyhq.com/ramp
figma.com    greenhouse:figma     177 open roles   boards.greenhouse.io/figma
gitlab.com   greenhouse:gitlab    189 open roles   boards.greenhouse.io/gitlab
```

### Call it as an API

One domain in, one row out, in a single HTTP call — no polling.

```bash
curl -X POST "https://api.apify.com/v2/acts/dev_web_col~ats-finder/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domain": "ramp.com"}'
```

```python
import requests

r = requests.post(
    "https://api.apify.com/v2/acts/dev_web_col~ats-finder/run-sync-get-dataset-items",
    params={"token": "YOUR_TOKEN"},
    json={"domain": "ramp.com"},
)
board = r.json()[0]
print(board["companyToken"], board["openJobs"], board["boardUrl"])
```

Pass `domains` instead of `domain` to check a whole account list in one call.

### Why this exists

Every job-data tool assumes you already know that Stripe is `greenhouse:stripe`
and Ramp is `ashby:ramp`. Nobody tells you where that comes from. This Actor is
the missing step: **domain in, board identifier out.**

The `companyToken` it returns (`ashby:ramp`) is the exact identifier other job
Actors accept, so the output of this one feeds straight into the next.

### How it finds the board — and how often it works

Two methods, run in order, because they rescue different companies:

| Method | What it does | Found |
|---|---|---|
| **Career page** | Reads the company's own `/careers` and follows the link to its ATS | 3 of 8 |
| **Endpoint probe** | Derives candidate tokens from the domain and confirms them against each ATS API | 3 more |
| **Combined** | | **6 of 8 — 75%** |

Every hit is confirmed against the live ATS endpoint before it is reported. A
board that does not answer with real data is not reported at all.

#### The 25% it misses, and why

Measured on the same run, the two failures are instructive and neither is fixable:

- **`deel.com`** — runs an applicant tracking system outside the six supported.
- **`nvidia.com`** — runs Workday, whose URL needs a tenant, a host number and a
  site name unique to each company (`NVIDIAExternalCareerSite`). Measured: 15
  guessed combinations per company, zero hits. It is not discoverable.

`found: false` means "no public board on a supported platform", not "this company
is not hiring".

### What you can use it for

| What you want | How to ask for it |
|---|---|
| **Enrich an account list** with hiring data | `domains: [...]`, read `openJobs` |
| **Sales triggers** — who is staffing up | Sort your list by `openJobs` |
| **Build a job aggregator** | `companyToken` feeds job-scraping Actors directly |
| **Recruiting competitive intel** | Track a competitive set's open-role counts |
| **Find a company's careers page** | `boardUrl`, confirmed live |
| **ATS market share research** | Group your list by `platform` |
| **Qualify inbound leads** | A company with 120 open roles has budget |
| **Live API lookup** from your product | `domain` via `run-sync-get-dataset-items` |

### Supported platforms

Greenhouse · Lever · Ashby · Workable · SmartRecruiters · Rippling

All six are read through their public JSON endpoints — the same feeds companies
use to embed job boards on their own sites. No login, no API key, no anti-bot
circumvention.

### Honest limits

- **75% detection**, measured on 8 real companies. Test your own list before
  committing to a big job.
- **Workday is not detectable** and it is the biggest enterprise ATS. If your
  list is Fortune 500, expect a low hit rate. This Actor is strongest on
  technology companies, startups and scale-ups.
- **`openJobs` is a live count** at the moment of the run, not a historical
  series.
- **A run stops after about 3.5 minutes** and delivers what it has, so Apify's
  automated checks never time it out. Split large lists across runs.
- **Company names are not accepted**, only domains. A domain is unambiguous; a
  name is not.

### FAQ

#### Do I need an API key for any of these platforms?

No. All six publish the endpoints this Actor reads so that companies can embed
their job boards elsewhere.

#### What is `companyToken` for?

It is `platform:token` — for example `ashby:ramp`. Job-scraping Actors take that
identifier directly, so you can pipe this Actor's output into one of them without
any translation step.

#### Why does it report `method`?

So you know how much to trust the row. `career-page` means the company links that
board from its own website, which is as certain as it gets. `probe` means the
token was derived and then confirmed against the live ATS endpoint — also
verified, just discovered differently.

#### A company I know is hiring came back `found: false`. Why?

Either its ATS is outside the six supported, or it runs Workday, whose board URLs
cannot be derived from a domain. Both cases are documented above.

#### Is it legal to read these endpoints?

They are public feeds published so that job boards can be embedded on company
websites. No login, no personal data — job counts and board addresses only.

#### Can I export to Excel, CSV or Google Sheets?

Yes, from the **Storage** tab of any run, plus the usual Apify integrations with
Google Sheets, Airtable, Zapier, Make and Slack.

#### Can I run it on a schedule?

Yes. Useful for tracking how a target account list's open-role counts move over
time.

### Related Actors

- **Job Scraper — Greenhouse, Lever & Ashby API** — feed it the `companyToken`
  from here and get the actual postings.
- **Company Data Scraper** — firmographics, emails and a hiring signal for the
  same domains.

### Where the data comes from

The public JSON endpoints of Greenhouse, Lever, Ashby, Workable, SmartRecruiters
and Rippling, plus the company's own careers page. No login, no API key.

# Actor input Schema

## `domain` (type: `string`):

One company website, for when you call this Actor as an API from your own code — one call in, one row out with their job board. For a list, use the field below.

## `domains` (type: `array`):

A list of company websites, one per line. Paste them straight from a CRM or a target account list — https://, www. and trailing paths are stripped for you.

## `onlyFound` (type: `boolean`):

Drops companies where no public board was found, so you only pay for usable rows. Leave it off if knowing who has no public board is also useful.

## `proxyConfiguration` (type: `object`):

Optional. The ATS endpoints answer fine without it. Turn it on when scanning hundreds of companies, since some corporate sites block datacenter IPs.

## Actor input object example

```json
{
  "domain": "ramp.com",
  "onlyFound": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `boards` (type: `string`):

One dataset item per company.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domain": "ramp.com",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dev_web_col/ats-finder").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "domain": "ramp.com",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("dev_web_col/ats-finder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domain": "ramp.com",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call dev_web_col/ats-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dev_web_col/ats-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/pGSYXkJ1upE219n7D/builds/tzpx0AuhVpuQXnduk/openapi.json