# Talent.com Jobs Scraper (`solidcode/talent-com-scraper`) Actor

\[💰 $1.30 / 1K] Extract job listings from Talent.com across 10 countries. Search by keyword, location, country, job type, remote, and posting date to get titles, companies, salaries, locations, full descriptions, and direct apply links — one clean row per job.

- **URL**: https://apify.com/solidcode/talent-com-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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

## Talent.com Jobs Scraper

Pull live job listings from Talent.com across 10 country markets — job titles, companies, full descriptions, parsed salaries, geo-coordinates, posting dates, and direct apply links, all as one clean row per posting. Search by keyword, country, and location, then narrow by job type, work arrangement, and posting date — or paste a Talent.com search URL and scrape it as-is. Built for recruiters, job-market researchers, and lead-generation teams who need structured Talent.com job data without copy-pasting listings one page at a time.

### Why This Scraper?

- **10 country markets in one input** — United States, Canada, United Kingdom, Germany, France, Netherlands, Belgium, Switzerland, Austria, and Norway, each with its own local board, currency, and language.
- **Full job descriptions, not snippets** — the complete posting text is pulled from each listing's detail page, so you get the whole role, requirements, and benefits instead of a truncated preview.
- **Geo-coordinates on every job** — latitude and longitude alongside parsed city, region, and country, so postings drop straight onto a map or into a radius query.
- **5 employment types x 3 work arrangements** — filter by Full-time, Part-time, Permanent, Temporary, or Internship, and by Remote, Hybrid, or On-site.
- **5 posting-date windows** — last 24 hours, 3, 7, 14, or 30 days; ideal for scheduled runs that collect only the newest jobs each morning.
- **Parsed salary fields** — minimum, maximum, currency, and pay period broken out into their own columns whenever the posting publishes a figure, plus the salary as originally displayed.
- **Direct apply links and canonical listing URLs** — send candidates straight to the employer's application page, with the Talent.com listing URL kept for reference.
- **Source-board provenance on every row** — see which job board or career site each posting was originally aggregated from.
- **Paste-a-URL mode** — drop up to 50 dialed-in Talent.com search URLs and scrape them exactly as they appear on the site, keyword and URL searches merged and de-duplicated in one run.

### Use Cases

**Recruiting & Talent Sourcing**
- Build fresh candidate-facing job feeds for a specific role and city
- Track competitor hiring by company across multiple countries
- Surface only remote or hybrid openings for distributed teams
- Assemble a daily digest of new postings with the last-24-hours filter

**Job Market Research**
- Measure hiring demand for a role across 10 national markets
- Compare on-site vs. remote vs. hybrid mix over time
- Map job density by city and region using geo-coordinates
- Analyze how postings for a keyword trend week over week

**Salary & Compensation Benchmarking**
- Collect published salary ranges by role and location
- Compare pay bands across countries and currencies
- Benchmark permanent vs. temporary compensation for the same title
- Feed parsed min/max salary into internal compensation models

**Lead Generation**
- Identify companies actively hiring in a target market
- Build outreach lists for staffing and recruitment agencies
- Spot employers posting high volumes of roles in your niche
- Enrich a CRM with the hiring companies behind each posting

**Data Enrichment & Aggregation**
- Power a job-board or aggregator with normalized listings
- Enrich an existing jobs dataset with descriptions and geo-data
- Feed structured postings into analytics dashboards
- Keep a search-alert product topped up with the newest jobs

### Getting Started

#### Simple Keyword Search

Just a keyword, country, and city:

```json
{
    "searchQueries": ["software engineer"],
    "country": "us",
    "location": "New York"
}
````

#### Filtered Search

The most common combination — recent, full-time roles across several keywords:

```json
{
    "searchQueries": ["registered nurse", "nurse practitioner"],
    "country": "uk",
    "location": "London",
    "jobType": "full-time",
    "datePosted": "7",
    "maxResults": 200
}
```

#### Advanced Search

Most options set — remote, permanent data roles in Germany with full descriptions:

```json
{
    "searchQueries": ["data analyst"],
    "country": "de",
    "location": "Berlin",
    "jobType": "permanent",
    "remote": "remote",
    "datePosted": "14",
    "maxResults": 500,
    "fetchDescription": true
}
```

#### Paste a Talent.com URL

Already dialed in a search on Talent.com? Paste the URL directly:

```json
{
    "startUrls": ["https://www.talent.com/jobs?k=marketing+manager&l=Toronto"],
    "maxResults": 100
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | `["software engineer"]` | Job titles or keywords to search for. Each keyword runs its own search and the results are merged and de-duplicated. Leave empty if you only want to use direct search URLs. |
| `country` | select | `United States` | Which Talent.com market to search. Options: United States, Canada, United Kingdom, Germany, France, Netherlands, Belgium, Switzerland, Austria, Norway. Each market has its own local board, currency, and language. |
| `location` | string | `""` | Where to search within the chosen country — a city, state, or region such as "New York" or "London". Leave empty to search the whole country. |
| `startUrls` | array | `[]` | Paste full Talent.com search-result URLs to scrape them exactly as-is. Handy when you have already tuned a search on the website. Up to 50 URLs per run. |

#### Filters & Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum jobs to collect for each keyword or URL (up to 5,000 per search). Use a small number for a quick scan or a larger one for deep research. Set to 0 for no cap (up to 5,000 per search). The final page is always kept in full, so the count can slightly overshoot. |
| `jobType` | select | `Any` | Employment type: Any, Full-time, Part-time, Permanent, Temporary, or Internship. |
| `remote` | select | `Any` | Work arrangement: Any, Remote only, Hybrid, or On-site. |
| `datePosted` | select | `Any time` | Only include jobs posted within a window: Any time, Last 24 hours, Last 3 days, Last 7 days, Last 14 days, or Last 30 days. |

#### Advanced

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `fetchDescription` | boolean | `true` | Fetch the full job description from each listing's detail page. Leave on for the most complete data; turn off for faster runs that return only the short search-result snippet. |

### Output

Every job is a single flat row. Here is a representative result:

```json
{
    "title": "Senior Software Engineer",
    "company": "Acme Technologies",
    "location": "New York, NY",
    "city": "New York",
    "region": "New York",
    "country": "US",
    "isRemote": false,
    "jobType": "fulltime",
    "salary": "USD 120,000–150,000 / year",
    "salaryMin": 120000,
    "salaryMax": 150000,
    "salaryCurrency": "USD",
    "salaryPeriod": "year",
    "descriptionSnippet": "We are looking for a Senior Software Engineer to join our platform team and help scale...",
    "description": "We are looking for a Senior Software Engineer to join our platform team and help scale our services. Responsibilities include designing APIs, mentoring engineers, and owning delivery end to end. Requirements: 5+ years of experience, strong system design skills...",
    "postedAt": "2026-07-15",
    "source": "acme-careers",
    "applyUrl": "https://acme.example.com/careers/senior-software-engineer",
    "jobUrl": "https://www.talent.com/view?id=abc123def456",
    "jobId": "abc123def456",
    "latitude": 40.7128,
    "longitude": -74.006,
    "searchQuery": "software engineer",
    "searchLocation": "New York",
    "scrapedAt": "2026-07-18T14:30:00+00:00"
}
```

#### Core Job Fields

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Job title |
| `company` | string | Hiring company or employer name |
| `location` | string | Location text as shown on the listing |
| `jobType` | string | Employment type (fulltime, part\_time, permanent, temporary, internship) |
| `isRemote` | boolean | Whether the role is remote-eligible |
| `postedAt` | string | Date the posting was found |

#### Salary

| Field | Type | Description |
|-------|------|-------------|
| `salary` | string | Salary as displayed, composed from the published figures (null when none is listed) |
| `salaryMin` | number | Parsed minimum salary, when published |
| `salaryMax` | number | Parsed maximum salary, when published |
| `salaryCurrency` | string | Currency of the salary values |
| `salaryPeriod` | string | Pay period the salary refers to (e.g. year, hour) |

#### Location & Geo

| Field | Type | Description |
|-------|------|-------------|
| `city` | string | Parsed city |
| `region` | string | Parsed state or region |
| `country` | string | Country code of the market searched |
| `latitude` | number | Job location latitude, when available |
| `longitude` | number | Job location longitude, when available |

#### Description

| Field | Type | Description |
|-------|------|-------------|
| `descriptionSnippet` | string | Short preview from the search result |
| `description` | string | Full job description (when Fetch Full Job Descriptions is on) |

#### Links & Identifiers

| Field | Type | Description |
|-------|------|-------------|
| `applyUrl` | string | Direct link to the employer's application page |
| `jobUrl` | string | Canonical Talent.com listing URL |
| `jobId` | string | Talent.com job identifier |
| `source` | string | Job board or career site the posting was aggregated from |

#### Run Metadata

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | Keyword that produced this row |
| `searchLocation` | string | Location used for the search |
| `scrapedAt` | string | ISO timestamp when the row was collected |

### Tips for Best Results

- **Start small, then scale** — set `maxResults` to 25–50 on your first run to confirm the data fits your needs, then raise it for a full pull.
- **Leave the location blank to sweep a whole country** — an empty `location` searches the entire market, which is the fastest way to gauge nationwide demand for a role.
- **Match the country to the market, not the language** — each country is its own localized board; searching Germany returns the German market's postings, so pick the country your candidates or research target actually live in.
- **Use the date-posted window for scheduled runs** — pair Last 24 hours with a daily schedule to capture only brand-new postings and avoid re-collecting the same jobs.
- **Turn off full descriptions for speed** — when you only need titles, companies, salaries, and links, switching off Fetch Full Job Descriptions makes runs noticeably faster.
- **Salary is sparse on Talent.com** — many postings publish no pay figure, so `salary`, `salaryMin`, and `salaryMax` are null on those rows; filter to jobs where `salaryMin` is present when you need compensation data.
- **Combine keywords and URLs in one run** — several keywords plus pasted search URLs are merged and de-duplicated automatically, so you never get the same job twice.

### Pricing

**From $1.30 per 1,000 results** — undercutting comparable Talent.com scrapers on the market. No compute or time-based charges: you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.16 | $0.15 | $0.14 | $0.13 |
| 1,000 | $1.55 | $1.45 | $1.40 | $1.30 |
| 10,000 | $15.50 | $14.50 | $14.00 | $13.00 |
| 100,000 | $155.00 | $145.00 | $140.00 | $130.00 |

A "result" is any job row in the output dataset. The Gold tier shows the lowest price; platform fees depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate recruiting, job-market research, and lead-generation use. You are responsible for complying with applicable laws and Talent.com's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data you collect in line with relevant privacy regulations.

# Actor input Schema

## `searchQueries` (type: `array`):

Job titles or keywords to search for, such as 'software engineer' or 'registered nurse'. Each keyword runs a separate search and the results are merged and de-duplicated. Leave empty if you only want to use the direct search URLs below.

## `country` (type: `string`):

Which Talent.com market to search. Each country has its own local job board, currency, and language.

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

Where to search within the chosen country. Enter a city, state, or region, such as 'New York' or 'London'. Leave empty to search the whole country.

## `startUrls` (type: `array`):

Paste full Talent.com search-result URLs (for example https://www.talent.com/jobs?k=software+engineer\&l=New+York) to scrape them exactly as-is. Useful when you have already dialed in a search on the Talent.com website. Up to 50 URLs per run.

## `maxResults` (type: `integer`):

Maximum number of jobs to collect for each search keyword or URL (up to 5,000 results per search). Use a small number for a quick scan or a higher number for deep research. Set to 0 for no cap (up to an internal maximum of 5,000 jobs per search). The last page is always kept in full, so the final count can slightly overshoot this number.

## `jobType` (type: `string`):

Filter by employment type. Leave on 'Any' to include all types.

## `remote` (type: `string`):

Filter by where the work happens. Leave on 'Any' to include all jobs.

## `datePosted` (type: `string`):

Only show jobs posted within this time period. Great for daily or weekly scheduled runs that pick up just the newest postings.

## `fetchDescription` (type: `boolean`):

Fetch the full job description from each listing's detail page. Leave on for the most complete data. Turn off to make runs faster — the description field will then contain only the short search-result snippet.

## Actor input object example

```json
{
  "searchQueries": [
    "software engineer"
  ],
  "country": "us",
  "startUrls": [],
  "maxResults": 100,
  "fetchDescription": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped job listings with key fields.

## `detail` (type: `string`):

Complete job data including full descriptions, parsed salary fields, source, and search provenance.

# 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 = {
    "searchQueries": [
        "software engineer"
    ],
    "country": "us",
    "location": "",
    "startUrls": [],
    "maxResults": 100,
    "jobType": "",
    "remote": "",
    "datePosted": "",
    "fetchDescription": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/talent-com-scraper").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 = {
    "searchQueries": ["software engineer"],
    "country": "us",
    "location": "",
    "startUrls": [],
    "maxResults": 100,
    "jobType": "",
    "remote": "",
    "datePosted": "",
    "fetchDescription": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/talent-com-scraper").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 '{
  "searchQueries": [
    "software engineer"
  ],
  "country": "us",
  "location": "",
  "startUrls": [],
  "maxResults": 100,
  "jobType": "",
  "remote": "",
  "datePosted": "",
  "fetchDescription": true
}' |
apify call solidcode/talent-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Talent.com Jobs Scraper",
        "description": "[💰 $1.30 / 1K] Extract job listings from Talent.com across 10 countries. Search by keyword, location, country, job type, remote, and posting date to get titles, companies, salaries, locations, full descriptions, and direct apply links — one clean row per job.",
        "version": "1.0",
        "x-build-id": "wWJBcIAhSFlCoOVCQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~talent-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-talent-com-scraper",
                "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/solidcode~talent-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-talent-com-scraper",
                "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/solidcode~talent-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-talent-com-scraper",
                "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": {
                    "searchQueries": {
                        "title": "Search Keywords",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Job titles or keywords to search for, such as 'software engineer' or 'registered nurse'. Each keyword runs a separate search and the results are merged and de-duplicated. Leave empty if you only want to use the direct search URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "us",
                            "ca",
                            "uk",
                            "de",
                            "fr",
                            "nl",
                            "be",
                            "ch",
                            "at",
                            "no"
                        ],
                        "type": "string",
                        "description": "Which Talent.com market to search. Each country has its own local job board, currency, and language."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Where to search within the chosen country. Enter a city, state, or region, such as 'New York' or 'London'. Leave empty to search the whole country."
                    },
                    "startUrls": {
                        "title": "Direct Talent.com Search URLs",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Paste full Talent.com search-result URLs (for example https://www.talent.com/jobs?k=software+engineer&l=New+York) to scrape them exactly as-is. Useful when you have already dialed in a search on the Talent.com website. Up to 50 URLs per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results per Search",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of jobs to collect for each search keyword or URL (up to 5,000 results per search). Use a small number for a quick scan or a higher number for deep research. Set to 0 for no cap (up to an internal maximum of 5,000 jobs per search). The last page is always kept in full, so the final count can slightly overshoot this number."
                    },
                    "jobType": {
                        "title": "Job Type",
                        "enum": [
                            "",
                            "full-time",
                            "part-time",
                            "permanent",
                            "temporary",
                            "internship"
                        ],
                        "type": "string",
                        "description": "Filter by employment type. Leave on 'Any' to include all types."
                    },
                    "remote": {
                        "title": "Work Arrangement",
                        "enum": [
                            "",
                            "remote",
                            "hybrid",
                            "on-site"
                        ],
                        "type": "string",
                        "description": "Filter by where the work happens. Leave on 'Any' to include all jobs."
                    },
                    "datePosted": {
                        "title": "Posted Within",
                        "enum": [
                            "",
                            "1",
                            "3",
                            "7",
                            "14",
                            "30"
                        ],
                        "type": "string",
                        "description": "Only show jobs posted within this time period. Great for daily or weekly scheduled runs that pick up just the newest postings."
                    },
                    "fetchDescription": {
                        "title": "Fetch Full Job Descriptions",
                        "type": "boolean",
                        "description": "Fetch the full job description from each listing's detail page. Leave on for the most complete data. Turn off to make runs faster — the description field will then contain only the short search-result snippet."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
