# Jooble Scraper | Job Postings Worldwide (`parseforge/jooble-scraper`) Actor

Aggregate job listings from Jooble across countries and industries with title, company, location, salary, source site, posted date, and full description. Track hiring trends, source candidates, run recruiting analytics, or feed job boards with structured global postings.

- **URL**: https://apify.com/parseforge/jooble-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Jobs, Lead generation, Business
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.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.
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.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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 💼 Jooble Job Listings Scraper

> 🚀 **Export Jooble job listings in seconds.** Search **2,000,000+ active jobs** by keywords and location — get title, company, salary, job type, description, and direct apply URL. Free API key, no scraping restrictions.

> 🕒 **Last updated:** 2026-05-21 · **📊 11 fields** per record · **🌍 69 countries** · **📋 2M+ active jobs** · **🔗 Aggregated from 1,000+ sources**

The **Jooble Job Listings Scraper** queries Jooble's official REST API and returns clean, structured job data for any keyword and location combination. Jooble aggregates postings from thousands of job boards, company career sites, and specialized portals — including LinkedIn, Indeed, ZipRecruiter, and corporate sites — giving you a single API call that covers the entire market.

This Actor delivers **11 fields per record**, including the job title, company name, location, salary range, employment type, source board, a description snippet, the direct job URL, and timestamps. A free Jooble API key is all you need to get started — registration takes under one minute.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Recruiters, HR analysts, talent market researchers, job board builders, compensation analysts, staffing agencies | Salary benchmarking, talent availability mapping, job board arbitrage, candidate sourcing automation, compensation reports |

---

### 📋 What the Jooble Scraper does

Four practical workflows in a single run:

- 🔍 **Keyword search.** Search by job title, skill, or any phrase — "python developer", "nurse practitioner", "data engineer".
- 📍 **Location filter.** Narrow to a city, state, region, or country — "New York", "London", "remote".
- 📦 **Bulk export.** Collect up to 1,000,000 job listings per run on paid plans.
- 📄 **Multi-page pagination.** Automatically pages through Jooble's result set until your `maxItems` limit is reached.

Each record includes the full job title, company name, location, salary (when listed), job type (full-time, part-time, contract), the source board where the listing originated, a description snippet, and the direct Jooble apply URL.

> 💡 **Why it matters:** manually browsing Jooble means clicking through hundreds of pages. This Actor pulls the raw job data directly from the API — no browser, no scraping, no blocks — and delivers it as a structured dataset ready to download as CSV, Excel, JSON, or XML.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Required</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>apiKey</code></td><td>string</td><td>Yes</td><td>-</td><td>Your Jooble API key (GUID). Free at <a href="https://jooble.org/api/about">jooble.org/api/about</a>.</td></tr>
<tr><td><code>keywords</code></td><td>string</td><td>Yes</td><td><code>"python developer"</code></td><td>Job title, skill, or keyword phrase to search for.</td></tr>
<tr><td><code>location</code></td><td>string</td><td>No</td><td><code>"New York"</code></td><td>City, state, or region. Leave empty for worldwide results.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>No</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**JSON Input Example - Basic search:**
```json
{
  "apiKey": "your-guid-api-key",
  "keywords": "python developer",
  "location": "New York",
  "maxItems": 100
}
````

**JSON Input Example - Nationwide search:**

```json
{
  "apiKey": "your-guid-api-key",
  "keywords": "registered nurse",
  "location": "",
  "maxItems": 500
}
```

> ⚠️ **Good to Know:** Your Jooble API key is a GUID format string (e.g. `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`). Get one for free at [jooble.org/api/about](https://jooble.org/api/about) - registration takes under 1 minute and does not require a credit card.

***

### 📊 Output

Each item in the dataset contains the following fields:

| Field | Type | Description | Example |
|---|---|---|---|
| `title` | string | Job posting title | `"Python Developer"` |
| `company` | string | Hiring company name | `"Caliber6"` |
| `location` | string | Job location | `"Brooklyn, NY"` |
| `url` | string | Direct link to the job on Jooble | `"https://jooble.org/jdp/88411..."` |
| `id` | string | Unique Jooble job ID | `"8841171645884594933"` |
| `salary` | string | Salary or pay rate (if listed) | `"$90k - $110k"` |
| `jobType` | string | Employment type | `"Full-time"` |
| `source` | string | Originating job board | `"betterteam.com"` |
| `description` | string | Job description snippet | `"...Backend: Python, Django..."` |
| `postedAt` | string | ISO timestamp of last update | `"2026-03-23T01:07:09.250"` |
| `scrapedAt` | string | ISO timestamp of collection | `"2026-05-21T01:05:35.798Z"` |

**Sample records (3 real results from a live run):**

```json
[
  {
    "title": "Full Stack Django/ReactJS Developer",
    "company": "Caliber6",
    "location": "Brooklyn, NY",
    "url": "https://jooble.org/jdp/8841171645884594933",
    "id": "8841171645884594933",
    "salary": "$90k - $110k",
    "jobType": "Full-time",
    "source": "betterteam.com",
    "description": "...Full Stack Developer (Django / React) Location: In-Person, Brooklyn, NY or Monsey, NY. Starting Compensation: $90,000-$110,000... Tech Stack: Backend: Python, Django Frontend: React, JavaScript Database: PostgreSQL...",
    "postedAt": "2026-03-23T01:07:09.2500000",
    "scrapedAt": "2026-05-22T01:05:35.798Z"
  },
  {
    "title": "Python Developer Remote",
    "company": "Mercor",
    "location": "New York, NY",
    "url": "https://jooble.org/jdp/1039190399909705512",
    "id": "1039190399909705512",
    "salary": "$100 per hour",
    "jobType": null,
    "source": "manatal.com",
    "description": "...Remote Duration: 1 month Commitment: 20 hours/week Role Responsibilities Develop and maintain complex, production-grade Python systems for real-world environments...",
    "postedAt": "2026-04-20T07:33:01.8400000",
    "scrapedAt": "2026-05-22T01:05:35.798Z"
  },
  {
    "title": "Python Developer",
    "company": "TWO95 International, Inc",
    "location": "New York, NY",
    "url": "https://jooble.org/jdp/-3184651237216613775",
    "id": "-3184651237216613775",
    "salary": null,
    "jobType": null,
    "source": "swooped.co",
    "description": "...Job Title: Python Developer Location: New York, NY Duration: 6+ months Core Requirements: Bachelor's degree in Computer Science or related field preferred, 5+ years of professional experience, Python expertise...",
    "postedAt": "2025-08-12T00:00:00.0000000",
    "scrapedAt": "2026-05-22T01:05:35.798Z"
  }
]
```

***

### ✨ Why choose this Actor

| Feature | Benefit |
|---|---|
| 🔑 **Official Jooble API** | Uses the sanctioned REST API - no scraping, no blocks, no IP bans |
| 🌐 **1,000+ source boards** | Aggregates Indeed, LinkedIn, ZipRecruiter, corporate sites, and more |
| ⚡ **Fast collection** | Returns up to 20 listings per API call, paginates automatically |
| 🧹 **Clean text output** | HTML stripped from descriptions - ready for NLP and analysis |
| 🆔 **Exact IDs** | Full 64-bit job IDs preserved without floating-point precision loss |
| 💰 **Salary when available** | Returns salary ranges exactly as Jooble reports them |
| 📤 **Export-ready** | CSV, Excel, JSON, and XML from the Apify dataset tab |

***

### 📈 How it compares to alternatives

| Actor | Data source | API key needed | Max items | Salary field |
|---|---|---|---|---|
| **Jooble Scraper (this)** | Jooble (1,000+ boards) | Free Jooble key | 1,000,000 | Yes |
| Greenhouse Jobs Scraper | Greenhouse boards only | None | Unlimited | Yes |
| Lever Jobs Scraper | Lever boards only | None | Unlimited | No |
| Workable Jobs Scraper | Workable boards only | None | Unlimited | No |
| Remotive Scraper | Remote jobs only | None | Unlimited | Yes |

***

### 🚀 How to use

1. **Get your free Jooble API key** - visit [jooble.org/api/about](https://jooble.org/api/about), fill in your name, email, and website, and copy the generated GUID key (takes under 1 minute).
2. **Open the Actor** on [Apify Console](https://console.apify.com/sign-up?fpr=vmoqkp).
3. **Enter your inputs** - paste your API key, enter keywords (e.g. "data scientist"), and optionally a location (e.g. "San Francisco").
4. **Set maxItems** - leave at 10 for a preview, or increase for bulk export.
5. **Download your dataset** - CSV, Excel, JSON, or XML from the dataset tab once the run finishes.

***

### 💼 Business use cases

#### Compensation and salary benchmarking

Collect salary data for specific roles across cities and industries. Compare `$90k - $110k` for Python developers in New York versus San Francisco to calibrate your offers. Use filters to target specific experience levels and employment types.

#### Talent market availability research

Run weekly scrapes for high-demand roles in your hiring markets. Track how many Python developer postings appear in Austin versus Seattle week over week. Feed the data into dashboards to identify where competition for talent is rising.

#### Job board and aggregator products

Build a niche job board that re-surfaces Jooble listings in a specific vertical (e.g. only healthcare, only remote, only contract). Use the `source` field to attribute listings correctly and the `url` field to deep-link applicants to the original posting.

#### Staffing and recruiting automation

Load thousands of job listings into a CRM or ATS to identify which companies are actively hiring. Use the `company` and `location` fields to segment outreach campaigns by geography and employer size.

***

### 🔌 Automating Jooble Scraper

Connect this Actor to your existing workflows without writing code:

- **Make (Integromat)** - Trigger on new dataset items, route to Google Sheets, Airtable, or Slack.
- **Zapier** - Auto-push new job records to HubSpot, Notion, or a spreadsheet.
- **Apify Schedules** - Run on a daily or weekly schedule to track the job market over time.
- **Webhooks** - POST dataset items to your own endpoint as soon as a run completes.
- **Apify API** - Programmatic access via REST - pull the dataset into any Python, Node.js, or Go pipeline.

***

### 🌟 Beyond business use cases

#### Research and academic studies

Analyze labor market trends - which skills are most in-demand, how salaries vary by geography, what job types are growing or shrinking. Export to CSV and load into Pandas, R, or any statistical tool.

#### Journalist and policy investigations

Track hiring activity at specific companies or across industries. Document remote work trends, salary disparities, or geographic concentration of tech jobs over time.

#### Non-profit and civic use

Help job seekers in underserved communities by aggregating local listings and publishing them through community portals. Map job opportunities relative to transportation access or cost of living.

#### Personal career planning

Run a targeted search for your target role and location, export to a spreadsheet, and systematically track and apply. Use the `postedAt` field to prioritize fresh listings.

***

### 🤖 Ask an AI assistant about this scraper

You can ask any AI assistant (Claude, ChatGPT, Gemini) about this Actor:

- "How do I use the Jooble Scraper to find data science jobs in Austin?"
- "What fields does the Jooble Scraper output?"
- "How do I schedule the Jooble Scraper to run weekly?"
- "How do I connect the Jooble Scraper output to Google Sheets via Make?"

***

### ❓ Frequently Asked Questions

#### 🔑 How do I get a Jooble API key?

Visit [jooble.org/api/about](https://jooble.org/api/about), fill in your name, position, email, and website URL, and submit the form. Jooble will generate a GUID key immediately. No credit card required.

#### 💸 Is the Jooble API free?

Yes. Jooble offers a free API tier for developers and webmasters. The API key is free and has no documented rate limits for standard usage.

#### 🌍 What countries does Jooble cover?

Jooble operates in 69 countries. You can search for jobs in the US, UK, Canada, Australia, Germany, France, and dozens more by entering the city or region in the `location` field.

#### 📦 How many jobs can I collect per run?

Free plan users are limited to 10 items per run. Paid plan users can collect up to 1,000,000 items per run.

#### 💰 Why are some salary fields null?

Many job postings do not include salary information. Jooble only returns a salary value when the original posting includes one. This is normal and not a bug.

#### 🏢 What job type values are returned?

The `jobType` field reflects what the source board reports - common values include "Full-time", "Part-time", "Contract", "Temporary", and empty/null when not specified.

#### 🔄 How do I get fresh results?

Run the Actor on a schedule (daily or weekly) using Apify's built-in scheduler. Each run queries the Jooble API in real time, so results always reflect the current job market.

#### 📄 Can I paginate through all results?

Yes. Set `maxItems` to a high number and the Actor automatically pages through Jooble's results until your limit is reached or no more listings are available.

#### 🧩 Can I combine this with other Apify Actors?

Yes. Chain this Actor with a data transformation or notification Actor using Apify's task chaining. For example, run this Actor, then use a downstream task to filter by salary and post matching jobs to Slack.

#### 🔗 Do the job URLs stay valid?

Job URLs point to Jooble's detail page for each listing. Individual listings may expire if the employer removes the posting, but the URL itself is accurate at the time of scraping.

#### ❓ What happens if my API key is invalid?

The Actor will exit with a clear error message: "API returned 403. Invalid or expired API key. Verify at jooble.org/api/about". No items are charged. Simply replace the key in your input and re-run.

***

### 🔌 Integrate with any app

Download your data in **CSV, JSON, XML, or Excel** — or connect live with:

**Spreadsheets:** Google Sheets, Microsoft Excel, Airtable
**Databases:** PostgreSQL, MySQL, MongoDB, BigQuery, Snowflake
**BI Tools:** Tableau, Power BI, Looker, Metabase
**Automation:** Make (Integromat), Zapier, n8n, Pipedream
**Code:** Python (pandas, requests), Node.js, R, Go via the Apify API

***

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [Greenhouse Jobs Scraper](https://apify.com/parseforge/greenhouse-jobs-scraper) | Scrape job listings from companies using the Greenhouse ATS |
| [Workable Jobs Scraper](https://apify.com/parseforge/workable-jobs-scraper) | Scrape job listings from companies using the Workable ATS |
| [Lever Jobs Scraper](https://apify.com/parseforge/lever-jobs-scraper) | Scrape job listings from companies using the Lever ATS |
| [Remotive Scraper](https://apify.com/parseforge/remotive-scraper) | Export remote-only job listings from Remotive.com |
| [Upwork Scraper](https://apify.com/parseforge/upwork-scraper) | Scrape freelance job postings from Upwork |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for scrapers covering jobs, companies, reviews, finance, and more.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

[Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)

***

> **⚠️ Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or in any way officially connected to Jooble. It uses Jooble's official public API. Only publicly available job listing data is collected. Use responsibly and in accordance with Jooble's terms of service.

# Actor input Schema

## `apiKey` (type: `string`):

Your Jooble API key (GUID format). Get your free API key at https://jooble.org/api/about — registration takes under 1 minute.

## `keywords` (type: `string`):

Job title, skills, or keywords to search for (e.g. 'python developer', 'data scientist', 'nurse').

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

City, state, or region to search in (e.g. 'New York', 'San Francisco', 'Remote').

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "keywords": "python developer",
  "location": "New York",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "keywords": "python developer",
    "location": "New York",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/jooble-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 = {
    "keywords": "python developer",
    "location": "New York",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/jooble-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 '{
  "keywords": "python developer",
  "location": "New York",
  "maxItems": 10
}' |
apify call parseforge/jooble-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jooble Scraper | Job Postings Worldwide",
        "description": "Aggregate job listings from Jooble across countries and industries with title, company, location, salary, source site, posted date, and full description. Track hiring trends, source candidates, run recruiting analytics, or feed job boards with structured global postings.",
        "version": "0.1",
        "x-build-id": "p2NuwnrPtZBYNBYfe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~jooble-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-jooble-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/parseforge~jooble-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-jooble-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/parseforge~jooble-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-jooble-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",
                "required": [
                    "apiKey",
                    "keywords"
                ],
                "properties": {
                    "apiKey": {
                        "title": "Jooble API Key",
                        "type": "string",
                        "description": "Your Jooble API key (GUID format). Get your free API key at https://jooble.org/api/about — registration takes under 1 minute."
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Job title, skills, or keywords to search for (e.g. 'python developer', 'data scientist', 'nurse')."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, state, or region to search in (e.g. 'New York', 'San Francisco', 'Remote')."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
