# Real-Time Jobs API | LinkedIn, Indeed, Workday, Glassdoor,... (`hermann_samimi/real-time-jobs-api-linkedin-indeed-workday-glassdoor`) Actor

Real-time Jobs API aggregating LinkedIn, Indeed, Workday, Glassdoor, ZipRecruiter, XING, Arbeitsagentur, ICIMS, Talent.com, Randstad, Hays, Recruit.net, Bayt, Built In, Job Bank Canada, Walmart Careers, Uber Careers, and more.

- **URL**: https://apify.com/hermann\_samimi/real-time-jobs-api-linkedin-indeed-workday-glassdoor.md
- **Developed by:** [Hermann Samimi](https://apify.com/hermann_samimi) (community)
- **Categories:** Jobs
- **Stats:** 31 total users, 4 monthly users, 100.0% runs succeeded, 21 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.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 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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Pingrole Job Search API

Fast, structured, and continuously updated job listings from **Germany**, **Canada**, **the USA**, **the Netherlands**, and **the UK** — sourced from LinkedIn, Indeed, and other major job boards.

Search by title, company, location, remote status, language, job-type flags, and more. Results are returned as clean, ready-to-use JSON records with 30+ data points per listing.

> **Coverage:** 🇩🇪 Germany · 🇨🇦 Canada · 🇺🇸 USA · 🇳🇱 Netherlands · 🇬🇧 UK

---

### Introduction

The Pingrole Job Search Actor gives you programmatic access to a structured, continuously refreshed job database covering Germany, Canada, the USA, the Netherlands, and the UK. Jobs are sourced from the major public boards — LinkedIn, Indeed, and others — and enriched with company data, role classification flags, and salary metadata where available.

The Actor supports rich filtering: job title, company, location, posting date range, remote/freelance/academic/B2B/part-time flags, language, country, and pagination. Each job record includes 30+ data points: title, description, company info, salary source, job level, URL, and classification flags.

---

### Getting Started

#### 1 — Subscribe

Visit the Actor page on Apify and click **Try for free** or subscribe to a plan. No credit card is required for the free tier.

#### 2 — Make your first run

Go to the **Input** tab, set your filters (e.g. `country: canada`, `title: engineer`), and click **Start**. When the run finishes, open the **Dataset** tab and export your results as JSON, CSV, Excel, or XML.

#### 3 — Integrate via API

Use the Apify API or any of the official client libraries (Python, JavaScript, etc.) to trigger runs and fetch results programmatically. Code examples are in the sections below.

---

### Authentication

All API calls require an **Apify API token**. Pass it as a query parameter:

````

?token=YOUR\_APIFY\_API\_TOKEN

```

Or in the `Authorization` header:

```

Authorization: Bearer YOUR\_APIFY\_API\_TOKEN

````

You can find your token in the Apify Console under **Settings → Integrations**.

---

### Response Structure

Each Actor run writes one dataset record per job. The run result object contains:

```json
{
  "ok": true,
  "total": 1240,
  "count": 10,
  "items": [ ...job records... ]
}
````

| Field | Description |
|---|---|
| `ok` | `true` on success |
| `total` | Total matching jobs in the database |
| `count` | Number of records returned in this run |
| `items` | Array of job objects |

On error:

```json
{
  "ok": false,
  "error": "Invalid filter value for 'language'"
}
```

***

### Endpoints

#### Actor Run (POST)

Trigger a run via the Apify API:

```
POST https://api.apify.com/v2/acts/{ACTOR_ID}/runs?token={YOUR_TOKEN}
Content-Type: application/json
```

Body: a JSON object with any combination of the input parameters below.

#### Dataset Fetch (GET)

After a run completes, fetch results from the dataset:

```
GET https://api.apify.com/v2/datasets/{DATASET_ID}/items?token={YOUR_TOKEN}
```

***

### Input Parameters

Set `action` to choose the endpoint. Default is `search_jobs`.

#### `action: search_jobs` (default)

All parameters are optional except those noted. Combine freely to narrow results.

| Parameter | Type | Match | Description |
|---|---|---|---|
| `country` | string | Exact | `canada`, `germany`, `netherlands`, `United States`, or `United Kingdom` |
| `language` | string | Exact | `en`, `fr`, or `de` |
| `title` | string | Partial | Job title (case-insensitive regex) |
| `company` | string | Partial | Company name |
| `location` | string | Partial | City / region string, e.g. `Toronto` |
| `site` | string | Exact | Job board, e.g. `indeed`, `linkedin` — comma-separated for multiple |
| `Remote` | boolean | Exact | `true` = remote jobs only |
| `Academic` | boolean | Exact | `true` = academic roles only |
| `Research` | boolean | Exact | `true` = research roles only |
| `Freelancer` | boolean | Exact | `true` = freelance roles only |
| `B2B` | boolean | Exact | `true` = B2B contract roles only |
| `PartTime` | boolean | Exact | `true` = part-time roles only |
| `datetime_from` | string | Date ≥ | ISO date e.g. `2026-01-01` or `2026-01-01@11:00` |
| `datetime_to` | string | Date ≤ | ISO date e.g. `2026-12-31` or `2026-12-31@17:45` |
| `limit` | integer | — | Records to return per run (1–100, default `10`) |
| `skip` | integer | — | Pagination offset (default `0`) |
| `sort_field` | string | — | `datetime_from` (default), `title`, `company`, `site`, `language`, `country` |
| `sort_direction` | integer | — | `-1` newest first (default) · `1` oldest first |

**Note on boolean flags:** Omit a flag to ignore it entirely. Set `true` to include only matching roles. Set `false` to exclude them.

#### `action: search_companies`

Returns a ranked list of companies that posted jobs, with job counts. **`country` and `limit` are required.**

| Parameter | Type | Required | Description |
|---|---|---|---|
| `country` | string | Yes | `canada`, `germany`, `netherlands`, `United States`, or `United Kingdom` |
| `limit` | integer | Yes | Companies to return (1–100) |
| `location` | string | No | Partial match on job location (regex) |
| `datetime_from` | string | No | Only count jobs posted on or after this date |
| `datetime_to` | string | No | Only count jobs posted on or before this date |
| `skip` | integer | No | Pagination offset (default `0`) |
| `sort_field` | string | No | `count` (default), `company`, `country` |
| `sort_direction` | integer | No | `-1` most jobs first (default) · `1` fewest first |

Output fields per company: `logo_url`, `country`, `company`, `count`.

***

### Example Inputs

**Latest 20 jobs in Canada:**

```json
{ "country": "canada", "limit": 20 }
```

**Remote software roles in Germany (German-language):**

```json
{
  "country": "germany",
  "title": "software",
  "Remote": true,
  "language": "de",
  "limit": 50
}
```

**LinkedIn jobs in Toronto, posted this month:**

```json
{
  "country": "canada",
  "site": "linkedin",
  "location": "Toronto",
  "datetime_from": "2026-05-01@00:00",
  "datetime_to": "2026-05-31@23:59",
  "limit": 100
}
```

**Page 2 of results (pagination):**

```json
{
  "country": "canada",
  "limit": 10,
  "skip": 10,
  "sort_field": "datetime_from",
  "sort_direction": -1
}
```

**Top 20 hiring companies in the United States:**

```json
{
  "action": "search_companies",
  "country": "United States",
  "limit": 20
}
```

**Top hiring companies in Canada, filtered by location and date:**

```json
{
  "action": "search_companies",
  "country": "canada",
  "location": "Toronto",
  "datetime_from": "2026-01-01",
  "limit": 50,
  "sort_field": "count",
  "sort_direction": -1
}
```

***

### Output Fields

Each job record includes the following fields. Missing values are returned as `null`.

| Field | Description |
|---|---|
| `id` | Internal job identifier |
| `job_id` | Source-specific job ID |
| `site` | Job board (e.g. `indeed`, `linkedin`) |
| `job_url` | Direct link to the listing |
| `title` | Job title |
| `company` | Company name |
| `location` | Location string |
| `job_type` | e.g. `fulltime`, `parttime` |
| `description` | Full job description |
| `salary_source` | Salary data source, if available |
| `currency` | Salary currency |
| `job_level` | Seniority level |
| `company_industry` | Industry |
| `company_url` | Company profile URL |
| `company_logo` | Logo image URL |
| `company_url_direct` | Company website |
| `company_addresses` | Company address(es) |
| `company_num_employees` | Employee count |
| `company_revenue` | Revenue info |
| `company_description` | Company description |
| `company_rating` | Company rating |
| `timestamp` | Scrape datetime (UTC) |
| `country` | `canada`, `germany`, `netherlands`, `United States`, or `United Kingdom` |
| `language` | `en`, `fr`, or `de` |
| `Remote` | Remote flag |
| `Academic` | Academic flag |
| `Research` | Research flag |
| `Freelancer` | Freelance flag |
| `B2B` | B2B flag |
| `PartTime` | Part-time flag |

#### Example Record

```json
{
  "id": "li-4374072722",
  "site": "linkedin",
  "job_url": "https://www.linkedin.com/jobs/view/4374072722",
  "title": "Software Engineer",
  "company": "Example GmbH",
  "location": "Berlin, DE",
  "job_type": "fulltime",
  "description": "We are looking for...",
  "salary_source": null,
  "currency": null,
  "job_level": "mid-senior",
  "company_industry": "Software Development",
  "company_url": "https://linkedin.com/company/example-gmbh",
  "company_logo": null,
  "company_url_direct": "https://example.com",
  "company_addresses": null,
  "company_num_employees": "51-200",
  "company_revenue": null,
  "company_description": "Example GmbH is a Berlin-based...",
  "company_rating": null,
  "job_id": "li-4374072722",
  "timestamp": "2026-05-16 14:50:09.053000",
  "country": "germany",
  "language": "de",
  "Academic": false,
  "Research": false,
  "Remote": true,
  "Freelancer": false,
  "B2B": false,
  "PartTime": false
}
```

***

### Code Examples

#### Python

```python
import json
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")

run = client.actor("YOUR_ACTOR_ID").call(run_input={
    "country": "canada",
    "title": "software engineer",
    "Remote": True,
    "datetime_from": "2026-01-01@11:00",
    "datetime_to": "2026-12-31@17:45",
    "limit": 25,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
for job in items:
    print(json.dumps(job, indent=4, ensure_ascii=False, default=str))
```

#### JavaScript / Node.js

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

const client = new ApifyClient({ token: 'YOUR_APIFY_API_TOKEN' });

const run = await client.actor('YOUR_ACTOR_ID').call({
  country: 'germany',
  title: 'data engineer',
  Remote: true,
  limit: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(job => console.log(job.title, job.company));
```

#### curl

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_APIFY_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"country": "canada", "title": "engineer", "Remote": true, "limit": 20}'
```

Then retrieve results:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_APIFY_API_TOKEN&format=json"
```

***

### Common Use Cases

- **Job board apps** — Power a job search UI with filtered, structured listings
- **Lead generation** — Find companies actively hiring in a specific role or location
- **Recruitment tools** — Feed filtered listings into your ATS, CRM, or Slack
- **Market research** — Compare job volume by title, region, or date range
- **Salary benchmarking** — Aggregate job-level and salary data across boards
- **Analytics pipelines** — Schedule daily runs and export to CSV / BigQuery / Sheets
- **Competitive intelligence** — Track hiring trends by company or job board

***

### Scheduling & Integrations

- **Schedule runs** in the Apify Console (e.g. daily at 08:00 UTC) to keep a dataset continuously fresh.
- **Webhooks** — trigger your downstream app or pipeline the moment a run succeeds.
- **Apify integrations** — connect directly to Google Sheets, Slack, Zapier, Make, Airtable, and more from the Actor run page.

***

### Rate Limiting & Limits

- Each run returns up to **100 records** per call (set via `limit`).
- Use `skip` + `limit` across multiple runs to paginate through large result sets.
- Apify enforces platform-level rate limits based on your subscription plan. See [Apify pricing](https://apify.com/pricing) for details.

***

### Error Handling

| HTTP Status | Meaning | Action |
|---|---|---|
| `400 Bad Request` | Malformed input or invalid parameter value | Check input types and allowed values |
| `401 Unauthorized` | Missing or invalid API token | Verify your token in Apify Console |
| `429 Too Many Requests` | Rate limit exceeded | Wait for reset or upgrade your plan |
| `500 Server Error` | Unexpected server error | Retry after a short delay; contact support if it persists |

All actor-level errors are surfaced in the **Log** tab of your run in the Apify Console.

***

### Live Dashboard

Explore the data interactively before integrating: **[realtime.pingrole.com](https://realtime.pingrole.com)**

***

### Support & Contact

Built by **Hermann Samimi** · [Pingrole](https://github.com/HermannSamimi)

For issues with a run, check the **Log** tab in the Apify Console.
For feature requests, data coverage questions, or custom plans:

- **Email:** <hermannsamimi@gmail.com>
- **Book a call:** [calendly.com/hermannsamimi/30min](https://calendly.com/hermannsamimi/30min)

***

<div align="center">

🇩🇪 Germany · 🇨🇦 Canada · 🇺🇸 USA · 🇳🇱 Netherlands · 🇬🇧 UK

</div>

# Actor input Schema

## `action` (type: `string`):

Which endpoint to call

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

Required for both actions

## `limit` (type: `integer`):

Results to return (max 100)

## `title` (type: `string`):

Required — partial match (regex)

## `company` (type: `string`):

Partial match (regex)

## `site` (type: `string`):

Exact match — linkedin, indeed, xing, glassdoor, ...

## `language` (type: `string`):

Exact match — en, fr, de

## `Remote` (type: `boolean`):

Remote jobs only

## `Academic` (type: `boolean`):

Academic roles only

## `Research` (type: `boolean`):

Research roles only

## `Freelancer` (type: `boolean`):

Freelance roles only

## `B2B` (type: `boolean`):

B2B contract roles only

## `PartTime` (type: `boolean`):

Part-time roles only

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

Required for search\_jobs — partial match (regex). Also filters by job location in search\_companies.

## `datetime_from` (type: `string`):

ISO date e.g. 2026-01-01 or 2026-01-01@11:00

## `datetime_to` (type: `string`):

ISO date e.g. 2026-12-31 or 2026-12-31@17:45

## `skip` (type: `integer`):

Pagination offset

## `sort_field` (type: `string`):

search\_jobs: datetime\_from, title, company, site, language, country — search\_companies: count, company, country

## `sort_direction` (type: `integer`):

-1 newest/most first (default) · 1 oldest/fewest first

## Actor input object example

```json
{
  "action": "search_jobs",
  "country": "canada",
  "limit": 10,
  "title": "software engineer",
  "language": "en",
  "location": "toronto",
  "skip": 0,
  "sort_field": "datetime_from",
  "sort_direction": -1
}
```

# 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 = {
    "action": "search_jobs",
    "country": "canada",
    "limit": 10,
    "title": "software engineer",
    "language": "en",
    "location": "toronto"
};

// Run the Actor and wait for it to finish
const run = await client.actor("hermann_samimi/real-time-jobs-api-linkedin-indeed-workday-glassdoor").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 = {
    "action": "search_jobs",
    "country": "canada",
    "limit": 10,
    "title": "software engineer",
    "language": "en",
    "location": "toronto",
}

# Run the Actor and wait for it to finish
run = client.actor("hermann_samimi/real-time-jobs-api-linkedin-indeed-workday-glassdoor").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 '{
  "action": "search_jobs",
  "country": "canada",
  "limit": 10,
  "title": "software engineer",
  "language": "en",
  "location": "toronto"
}' |
apify call hermann_samimi/real-time-jobs-api-linkedin-indeed-workday-glassdoor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=hermann_samimi/real-time-jobs-api-linkedin-indeed-workday-glassdoor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Real-Time Jobs API | LinkedIn, Indeed, Workday, Glassdoor,...",
        "description": "Real-time Jobs API aggregating LinkedIn, Indeed, Workday, Glassdoor, ZipRecruiter, XING, Arbeitsagentur, ICIMS, Talent.com, Randstad, Hays, Recruit.net, Bayt, Built In, Job Bank Canada, Walmart Careers, Uber Careers, and more.",
        "version": "0.0",
        "x-build-id": "ZG2LJA8z1kpUZuXFX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hermann_samimi~real-time-jobs-api-linkedin-indeed-workday-glassdoor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hermann_samimi-real-time-jobs-api-linkedin-indeed-workday-glassdoor",
                "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/hermann_samimi~real-time-jobs-api-linkedin-indeed-workday-glassdoor/runs": {
            "post": {
                "operationId": "runs-sync-hermann_samimi-real-time-jobs-api-linkedin-indeed-workday-glassdoor",
                "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/hermann_samimi~real-time-jobs-api-linkedin-indeed-workday-glassdoor/run-sync": {
            "post": {
                "operationId": "run-sync-hermann_samimi-real-time-jobs-api-linkedin-indeed-workday-glassdoor",
                "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",
                "required": [
                    "country",
                    "limit"
                ],
                "properties": {
                    "action": {
                        "title": "Action",
                        "enum": [
                            "search_jobs",
                            "search_companies"
                        ],
                        "type": "string",
                        "description": "Which endpoint to call",
                        "default": "search_jobs"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "canada",
                            "germany",
                            "netherlands",
                            "United States",
                            "United Kingdom"
                        ],
                        "type": "string",
                        "description": "Required for both actions"
                    },
                    "limit": {
                        "title": "Limit",
                        "maximum": 100,
                        "type": "integer",
                        "description": "Results to return (max 100)",
                        "default": 10
                    },
                    "title": {
                        "title": "Job Title",
                        "type": "string",
                        "description": "Required — partial match (regex)",
                        "default": "software engineer"
                    },
                    "company": {
                        "title": "Company",
                        "type": "string",
                        "description": "Partial match (regex)"
                    },
                    "site": {
                        "title": "Site",
                        "type": "string",
                        "description": "Exact match — linkedin, indeed, xing, glassdoor, ..."
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Exact match — en, fr, de",
                        "default": "en"
                    },
                    "Remote": {
                        "title": "Remote",
                        "type": "boolean",
                        "description": "Remote jobs only"
                    },
                    "Academic": {
                        "title": "Academic",
                        "type": "boolean",
                        "description": "Academic roles only"
                    },
                    "Research": {
                        "title": "Research",
                        "type": "boolean",
                        "description": "Research roles only"
                    },
                    "Freelancer": {
                        "title": "Freelancer",
                        "type": "boolean",
                        "description": "Freelance roles only"
                    },
                    "B2B": {
                        "title": "B2B",
                        "type": "boolean",
                        "description": "B2B contract roles only"
                    },
                    "PartTime": {
                        "title": "Part Time",
                        "type": "boolean",
                        "description": "Part-time roles only"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Required for search_jobs — partial match (regex). Also filters by job location in search_companies.",
                        "default": "toronto"
                    },
                    "datetime_from": {
                        "title": "Date From",
                        "type": "string",
                        "description": "ISO date e.g. 2026-01-01 or 2026-01-01@11:00"
                    },
                    "datetime_to": {
                        "title": "Date To",
                        "type": "string",
                        "description": "ISO date e.g. 2026-12-31 or 2026-12-31@17:45"
                    },
                    "skip": {
                        "title": "Skip",
                        "type": "integer",
                        "description": "Pagination offset",
                        "default": 0
                    },
                    "sort_field": {
                        "title": "Sort Field",
                        "enum": [
                            "datetime_from",
                            "title",
                            "company",
                            "site",
                            "language",
                            "country",
                            "count"
                        ],
                        "type": "string",
                        "description": "search_jobs: datetime_from, title, company, site, language, country — search_companies: count, company, country",
                        "default": "datetime_from"
                    },
                    "sort_direction": {
                        "title": "Sort Direction",
                        "type": "integer",
                        "description": "-1 newest/most first (default) · 1 oldest/fewest first",
                        "default": -1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```