# Targeted ATS Jobs Feed (`ratio_tech/ats-aggregator`) Actor

Track a specific list of companies across Ashby, Workday, SmartRecruiters, Recruitee, Greenhouse & Lever — live jobs in one normalized schema, filtered by stack, remote, salary & seniority. Official APIs, real-time, no stale postings.

- **URL**: https://apify.com/ratio\_tech/ats-aggregator.md
- **Developed by:** [Marius Matulevicius](https://apify.com/ratio_tech) (community)
- **Categories:** Jobs, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Targeted ATS Jobs Feed — track the companies you choose

**Name the companies you care about, get their live jobs in one clean schema.** This actor scrapes the exact companies you list across **Ashby, Workday, SmartRecruiters, Recruitee, Greenhouse, and Lever** — straight from each ATS's official API, in real time, every run. No pre-indexed database, no firehose to filter down, no stale postings. You get precisely the companies you asked for, normalized into one shape, with filters for stack, remote, salary, and seniority.

This is the **scalpel, not the firehose.** If you have a *specific list* of companies to watch — competitors, target employers, portfolio companies, accounts — this pulls their current openings directly from the source, so nothing is stale or removed. (Want to search the whole job market instead? See [when to use a firehose](#targeted-vs-whole-market) below — I'll point you to the right tool.)

```json
{
  "source": "ashby",
  "company": "Ramp",
  "title": "Senior Backend Engineer",
  "location": "New York, NY",
  "isRemote": false,
  "workplaceType": "Hybrid",
  "seniority": null,
  "salaryMin": 180000,
  "salaryMax": 240000,
  "salaryCurrency": "USD",
  "compUnknown": false,
  "detectedStack": ["Go", "PostgreSQL", "React"],
  "descriptionText": "We're looking for...",
  "jobUrl": "https://jobs.ashbyhq.com/Ramp/...",
  "applyUrl": "https://jobs.ashbyhq.com/Ramp/.../application"
}
````

👉 **Try it now:** hit **Run** with the default input. It pulls a live board, filtered, and returns normalized jobs in seconds. Then swap in your own list of companies from any of the six ATSs.

***

### Targeted vs whole-market

There are two kinds of ATS job tool, and they're good at opposite things. Be honest with yourself about which job you have:

| | **This actor (targeted)** | Whole-market aggregators |
|---|---|---|
| **Best for** | A *known list* of companies to watch | "Show me every remote React job anywhere" |
| **How it works** | Live-scrapes the companies you name, this run | Search a pre-indexed database of millions of jobs |
| **Freshness** | Real-time from the source — nothing stale/removed | As fresh as the last index refresh |
| **Noise** | Only the companies you asked for | The whole market, then you filter it down |
| **Coverage** | 6 ATSs, any company on them | 75–100+ ATSs, millions of jobs |

**If you need to search the entire job market**, a broad aggregator (e.g. jobo.world's ATS Jobs API, 100+ platforms) is the right tool and I'd point you there — no single tool wins at everything. **If you need to watch a specific set of companies, live and precisely**, that's exactly what this does, and a firehose makes you fight noise to get it.

***

### Who this is for

- **Competitive & sales intelligence** — track a fixed list of target/competitor companies and get their new openings live. A new eng req is a real hiring signal, straight from the source with no index lag.
- **Recruiters & sourcers** — watch the exact companies you recruit against; pull their whole current req list, salary bands included, into a sheet.
- **Job seekers (devs)** — point it at the companies you'd actually work for, filter to your stack + salary, get one ranked list. See [Using it as a developer](#using-it-as-a-developer).
- **Recruiting-intelligence tools** — one consistent job record per watched company, regardless of which ATS they use.
- **AI agents & data pipelines** — one tool call → live, normalized jobs for a named set of companies.

***

### What you get that a firehose doesn't

Because it scrapes your named companies **live**, and because it's built for precision rather than scale, it gives you a few things broad aggregators tend not to:

- **Real-time, not indexed** — every job comes straight from the ATS API on the run, so you never get a posting that was already filled or pulled.
- **`detectedStack`** — the tech named in each posting (`["Go", "Kubernetes", "React"]`), scanned deterministically. Filter or sort on it. (No AI-guessed skills — literal matches.)
- **Ashby compensation from the official field** — the exact published band, not a calculated/normalized estimate. `compUnknown` flags honestly when pay isn't disclosed.

And it still does the boring-but-necessary part: the six ATSs each expose *different* data under *different* field names, and this actor reconciles them into one schema:

| | Ashby | Workday | SmartRecruiters | Recruitee | Greenhouse | Lever |
|---|---|---|---|---|---|---|
| Compensation | ✅ published range | — | — | — | — | — |
| Seniority | — | — | ✅ | ✅ | — | — |
| Structured city/region/country | — | — | ✅ | partial | — | — |
| Remote/Hybrid/Onsite | ✅ | ✅ | ✅ | ✅ | best-effort | ✅ |
| Full description | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |

You get **one `UnifiedJob` schema** with all of it — and an honest **`compUnknown`** flag so you always know when a salary field is genuinely absent versus zero. Nothing is faked or inferred.

***

### The fit filters

Every run can filter server-side, so you only pay for jobs you actually want:

- **`stackKeywords`** — keep jobs whose title/description mention your stack (`["python", "kubernetes"]`). ANY match by default, or require ALL.
- **`remoteOnly`** — remote roles only.
- **`minSalary`** — salary floor. *Only Ashby exposes pay*, so jobs with unknown comp still pass by default (flagged `compUnknown`) — set **`dropUnknownSalary`** for strict "only jobs with a real published band ≥ X."
- **`seniority`** — match a level (`"Senior"`). Only SmartRecruiters/Recruitee expose it; others pass unless **`dropUnknownSeniority`**.
- **`location`** — substring-match against location/city/region/country.
- **`postedWithinDays`** — only jobs published in the last N days. Run it daily for a "fresh jobs" feed.

Filters are honest: an unset filter passes everything, and "unknown" fields are surfaced, never silently dropped (unless you opt into strict mode).

Two things every job also gets, computed for you:

- **`detectedStack`** — the tech mentioned in the posting (`["Go", "Kubernetes", "React"]`), scanned from the description. Filter or sort on it downstream.
- **Salary-ranked output** — results come back sorted by top-of-band pay (highest first, unknown-comp last), so the best-paying roles are at the top of the dataset.

***

### Using it as a developer

Aggregating jobs isn't only for data buyers — it's a great personal tool. Point it at the companies you'd actually work for, filter to your stack and salary floor, and get one ranked list instead of checking twenty career pages:

```json
{
  "ashby": ["Ramp", "Notion", "Linear"],
  "smartrecruiters": ["Equinox"],
  "stackKeywords": ["typescript", "react"],
  "remoteOnly": true,
  "minSalary": 150000,
  "postedWithinDays": 7,
  "maxJobsPerTarget": 500
}
```

That returns remote TypeScript/React roles paying ≥ $150K (where the company published pay), posted in the last week, ranked by salary, with `detectedStack` on each so you can see the full tech at a glance.

***

### Quick start

Give it targets for any of the six ATSs (mix freely), plus optional filters:

```json
{
  "ashby": ["Ramp", "Notion"],
  "workday": ["https://paypal.wd1.myworkdayjobs.com/jobs"],
  "smartrecruiters": ["Equinox"],
  "recruitee": ["bunq"],
  "stackKeywords": ["engineer"],
  "remoteOnly": true,
  "maxJobsPerTarget": 500
}
```

**Finding targets:**

- **Ashby** — board name in `jobs.ashbyhq.com/CompanyName` (or paste the URL).
- **Workday** — the full `*.myworkdayjobs.com/...` career URL.
- **SmartRecruiters** — slug in `jobs.smartrecruiters.com/CompanyName` (or the URL).
- **Recruitee** — subdomain in `CompanyName.recruitee.com` (or the URL).
- **Greenhouse** — board token in `boards.greenhouse.io/CompanyName` (or the URL).
- **Lever** — slug in `jobs.lever.co/CompanyName` (or the URL).

***

### Output

One normalized record per matching job (full field list in the dataset schema): `source`, `company`, `title`, `department`, `location`/`city`/`region`/`country`, `isRemote`, `workplaceType`, `employmentType`, `seniority`, `compensationRaw`, `salaryMin`/`salaryMax`/`salaryCurrency`, `compUnknown`, `tags`, `publishedAt`, `descriptionText`, `descriptionHtml`, `jobUrl`, `applyUrl`. Export as JSON, CSV, Excel, or via API.

***

### Pricing

**Pay per result** — billed only for jobs that match your filter and are written to the dataset. Filtered-out jobs are never pushed, so you never pay for them. Unknown targets and failed fetches go to a separate, **unbilled** errors dataset. One ATS being down never fails the run — the others still return data.

***

### For AI agents

Call this tool to get open job postings across Ashby, Workday, SmartRecruiters, Recruitee, Greenhouse, and Lever in one normalized schema. Input: per-ATS target lists (board names / career URLs / company slugs) plus optional filters (`stackKeywords`, `remoteOnly`, `minSalary`, `seniority`, `location`). Returns one `UnifiedJob` record per matching job. Public data, no login. Not for applicant/candidate data.

***

### Proxy

All six sources are public, documented endpoints with minimal anti-bot measures. **Datacenter proxies are sufficient.**

***

### Need just one ATS?

If you only scrape a single platform, the dedicated actors have per-ATS SEO and simpler input:

- [Ashby Jobs Scraper](https://apify.com/ratio_tech/ashby-scraper) — Ashby boards, with compensation ranges
- [Workday Jobs Scraper](https://apify.com/ratio_tech/workday-scraper) — any Workday career site
- [SmartRecruiters Jobs Scraper](https://apify.com/ratio_tech/smartrecruiters-scraper) — structured fields
- [Recruitee Jobs Scraper](https://apify.com/ratio_tech/recruitee-scraper) — any Recruitee career site

***

### Legal & compliance notice

This actor uses the **official, public, documented posting APIs** of each ATS — the same endpoints that power companies' public career pages. No login is used. Job-posting content is **company data, not personal data about candidates**. The buyer bears sole responsibility for compliance with each ATS's and company's Terms and applicable data-protection/employment laws. Intended for job aggregation, labor-market research, compensation benchmarking, and recruiting intelligence.

# Actor input Schema

## `ashby` (type: `array`):

Ashby board names (e.g. 'Ramp') or full jobs.ashbyhq.com URLs. Ashby is the only source that exposes compensation.

## `workday` (type: `array`):

Full Workday career-site URLs, e.g. 'https://paypal.wd1.myworkdayjobs.com/jobs'.

## `smartrecruiters` (type: `array`):

SmartRecruiters company slugs (e.g. 'Equinox') or full jobs.smartrecruiters.com URLs.

## `recruitee` (type: `array`):

Recruitee company subdomains (e.g. 'bunq') or full \*.recruitee.com URLs.

## `greenhouse` (type: `array`):

Greenhouse board tokens (e.g. 'stripe') or full boards.greenhouse.io URLs.

## `lever` (type: `array`):

Lever company slugs (e.g. 'leverdemo') or full jobs.lever.co URLs.

## `stackKeywords` (type: `array`):

Keep only jobs whose title or description contains these (case-insensitive). By default ANY match keeps the job.

## `keywordsMatchAll` (type: `boolean`):

When on, a job must contain every keyword (AND) instead of any (OR).

## `remoteOnly` (type: `boolean`):

Keep only jobs flagged remote by the source.

## `minSalary` (type: `integer`):

Keep only jobs paying at least this (top of the published band). Only Ashby exposes pay — jobs with unknown compensation still pass unless 'Drop unknown salary' is on.

## `dropUnknownSalary` (type: `boolean`):

Strict mode: when Minimum salary is set, also drop every job whose compensation is unknown (i.e. keep only Ashby jobs with a parseable published band).

## `seniority` (type: `string`):

Substring-match a seniority/experience level (e.g. 'Senior'). Only SmartRecruiters and Recruitee expose this — Ashby/Workday jobs pass unless 'Drop unknown seniority' is on.

## `dropUnknownSeniority` (type: `boolean`):

Strict mode: when Seniority is set, also drop jobs whose seniority is unknown.

## `location` (type: `string`):

Substring-match against a job's location/city/region/country (e.g. 'Berlin', 'United States').

## `postedWithinDays` (type: `integer`):

Keep only jobs published in the last N days — great for a daily 'fresh jobs' run. Jobs with no publish date pass (not silently dropped).

## `maxJobsPerTarget` (type: `integer`):

Cap on jobs fetched per board/company/site BEFORE filtering.

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

Apify Proxy settings. Datacenter proxies are sufficient — all four sources are public, documented endpoints with minimal anti-bot measures.

## Actor input object example

```json
{
  "ashby": [
    "Ashby"
  ],
  "keywordsMatchAll": false,
  "remoteOnly": false,
  "dropUnknownSalary": false,
  "dropUnknownSeniority": false,
  "maxJobsPerTarget": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `errors` (type: `string`):

No description

# 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 = {
    "ashby": [
        "Ashby"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ratio_tech/ats-aggregator").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 = { "ashby": ["Ashby"] }

# Run the Actor and wait for it to finish
run = client.actor("ratio_tech/ats-aggregator").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 '{
  "ashby": [
    "Ashby"
  ]
}' |
apify call ratio_tech/ats-aggregator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Targeted ATS Jobs Feed",
        "description": "Track a specific list of companies across Ashby, Workday, SmartRecruiters, Recruitee, Greenhouse & Lever — live jobs in one normalized schema, filtered by stack, remote, salary & seniority. Official APIs, real-time, no stale postings.",
        "version": "0.1",
        "x-build-id": "MDsLDKJ2hE8pPYSVV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ratio_tech~ats-aggregator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ratio_tech-ats-aggregator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/ratio_tech~ats-aggregator/runs": {
            "post": {
                "operationId": "runs-sync-ratio_tech-ats-aggregator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/ratio_tech~ats-aggregator/run-sync": {
            "post": {
                "operationId": "run-sync-ratio_tech-ats-aggregator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "ashby": {
                        "title": "Ashby boards",
                        "type": "array",
                        "description": "Ashby board names (e.g. 'Ramp') or full jobs.ashbyhq.com URLs. Ashby is the only source that exposes compensation.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "workday": {
                        "title": "Workday career URLs",
                        "type": "array",
                        "description": "Full Workday career-site URLs, e.g. 'https://paypal.wd1.myworkdayjobs.com/jobs'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "smartrecruiters": {
                        "title": "SmartRecruiters companies",
                        "type": "array",
                        "description": "SmartRecruiters company slugs (e.g. 'Equinox') or full jobs.smartrecruiters.com URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "recruitee": {
                        "title": "Recruitee companies",
                        "type": "array",
                        "description": "Recruitee company subdomains (e.g. 'bunq') or full *.recruitee.com URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "greenhouse": {
                        "title": "Greenhouse boards",
                        "type": "array",
                        "description": "Greenhouse board tokens (e.g. 'stripe') or full boards.greenhouse.io URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "lever": {
                        "title": "Lever companies",
                        "type": "array",
                        "description": "Lever company slugs (e.g. 'leverdemo') or full jobs.lever.co URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "stackKeywords": {
                        "title": "Stack / role keywords",
                        "type": "array",
                        "description": "Keep only jobs whose title or description contains these (case-insensitive). By default ANY match keeps the job.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywordsMatchAll": {
                        "title": "Require ALL keywords",
                        "type": "boolean",
                        "description": "When on, a job must contain every keyword (AND) instead of any (OR).",
                        "default": false
                    },
                    "remoteOnly": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Keep only jobs flagged remote by the source.",
                        "default": false
                    },
                    "minSalary": {
                        "title": "Minimum salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only jobs paying at least this (top of the published band). Only Ashby exposes pay — jobs with unknown compensation still pass unless 'Drop unknown salary' is on."
                    },
                    "dropUnknownSalary": {
                        "title": "Drop unknown salary",
                        "type": "boolean",
                        "description": "Strict mode: when Minimum salary is set, also drop every job whose compensation is unknown (i.e. keep only Ashby jobs with a parseable published band).",
                        "default": false
                    },
                    "seniority": {
                        "title": "Seniority",
                        "type": "string",
                        "description": "Substring-match a seniority/experience level (e.g. 'Senior'). Only SmartRecruiters and Recruitee expose this — Ashby/Workday jobs pass unless 'Drop unknown seniority' is on."
                    },
                    "dropUnknownSeniority": {
                        "title": "Drop unknown seniority",
                        "type": "boolean",
                        "description": "Strict mode: when Seniority is set, also drop jobs whose seniority is unknown.",
                        "default": false
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Substring-match against a job's location/city/region/country (e.g. 'Berlin', 'United States')."
                    },
                    "postedWithinDays": {
                        "title": "Posted within (days)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Keep only jobs published in the last N days — great for a daily 'fresh jobs' run. Jobs with no publish date pass (not silently dropped)."
                    },
                    "maxJobsPerTarget": {
                        "title": "Max jobs per target",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Cap on jobs fetched per board/company/site BEFORE filtering.",
                        "default": 1000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Datacenter proxies are sufficient — all four sources are public, documented endpoints with minimal anti-bot measures.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
