# The Hub Jobs Scraper (`solidcode/thehub-io-scraper`) Actor

\[💰 $3 / 1K] Extract startup job listings from thehub.io, the Nordic startup jobs board. Search by keyword, filter by region or position type, or paste job and search URLs. Returns title, company, location, salary range, equity, remote flag, view counts, and the apply link per job.

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

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## The Hub Jobs Scraper

Pull startup and tech job listings from [thehub.io](https://thehub.io) at scale — titles, full descriptions, salary ranges, equity offers, view counts, hiring-company profiles, and verified external apply links across the Nordic and broader European startup ecosystem. Built for recruiters, talent sourcers, and market researchers who need a clean, structured feed of the Nordic startup hiring market without copying jobs off the site one tab at a time.

### Why This Scraper?

- **6 Nordic + EU regions in one run** — Denmark, Sweden, Norway, Finland, Iceland, and broader Europe, plus a dedicated remote bucket. Leave the filter blank and every region is scanned and de-duplicated automatically.
- **7 position types, from Full-time to Advisory board** — filter to Full-time, Part-time, Internship, Freelance, Cofounder, Student, or Advisory-board roles, the full set The Hub itself exposes.
- **Salary range, equity, and view counts on every posting** — each row carries `salaryMin`/`salaryMax`, the equity offer, and both this-week and all-time view counts — signals you won't find on a generic job board.
- **Verified external apply link per job** — the real destination URL (or apply email) a candidate uses, pulled from the job's own detail page, not a dead-end redirect.
- **Full hiring-company profile attached** — company name, website, employee-count range, founding year, "what we do" blurb, and logo URL on every job, turning each listing into a startup lead.
- **Every job enriched with full detail-page data** — descriptions (HTML and plain text), salary, equity, and apply link come from each job's own page, not just the thin listing summary.
- **View-count signal to spot hot roles** — `viewsWeek` and `viewsTotal` let you rank by momentum and surface the postings candidates are actually clicking.
- **Paste a pre-filtered URL or target exact jobs** — build filters in The Hub's own UI and paste the search URL, or drop in specific `thehub.io/jobs/<id>` links to scrape just those postings.
- **Flat, de-duplicated output** — one clean row per job, with featured and sponsored placements merged so the same posting never appears twice.

### Use Cases

**Recruitment & Talent Sourcing**
- Build a live feed of open startup roles by region and position type
- Track which Nordic startups are hiring for a given skill or title
- Surface cofounder and advisory-board openings that rarely hit mainstream boards
- Rank roles by weekly view count to prioritize the most active listings

**Market & Salary Research**
- Benchmark salary ranges by role, country, and company size
- Map hiring demand across Denmark, Sweden, Norway, Finland, and Iceland
- Compare equity offers across early-stage vs. later-stage startups
- Measure remote-friendly hiring share across the Nordic ecosystem

**Competitive Intelligence**
- Watch a competitor's job postings to infer team growth and roadmap
- Detect new market entrants by tracking first-time hiring companies
- Spot which functions (engineering, growth, sales) startups are scaling

**Lead Generation & Sales**
- Build startup lead lists with company name, website, size, and founding year
- Target fast-growing companies by hiring velocity and employee-count range
- Enrich a CRM with verified company websites pulled from active job posts

**Data & Integration**
- Power a jobs aggregator or talent marketplace with structured Nordic listings
- Feed hiring-trend dashboards with fresh salary, region, and view-count data
- Set up alerts on new postings matching a saved keyword and region filter

### Getting Started

#### Simple Keyword Search

The quickest start — one keyword, default cap:

```json
{
    "searchQuery": "software engineer",
    "maxResults": 100
}
````

#### Region + Position-Type Filter

Narrow to full-time engineering roles in Denmark and Sweden:

```json
{
    "searchQuery": "backend developer",
    "regions": ["DK", "SE"],
    "jobPositionTypes": ["Full-time"],
    "remoteOnly": false,
    "maxResults": 200
}
```

#### Remote-Only Across Every Region

Collect remote-friendly roles regardless of country:

```json
{
    "searchQuery": "product manager",
    "remoteOnly": true,
    "maxResults": 150
}
```

#### Paste a Pre-Filtered Search URL or Target Specific Jobs

Build filters in The Hub's UI and paste the URL, or scrape exact postings:

```json
{
    "searchUrls": ["https://thehub.io/jobs?search=designer&location=DK"],
    "jobUrls": ["https://thehub.io/jobs/63f1a2b4c8d9e0f1a2b3c4d5"],
    "maxResults": 100
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | *none* | Job title, role, or skill to search for (pre-filled with `"software engineer"` as an example you can clear or replace). Leave blank to collect all jobs matching the filters below. |
| `regions` | select\[] | `[]` | Restrict to these regions: Denmark, Sweden, Norway, Finland, Iceland, Europe (other), or Remote. Empty includes every region. |
| `jobPositionTypes` | select\[] | `[]` | Restrict to these employment types: Full-time, Part-time, Internship, Freelance, Cofounder, Student, or Advisory board. Empty includes all types. |
| `remoteOnly` | boolean | `false` | Turn on to return only jobs that allow remote work. |

#### Or Paste URLs

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchUrls` | string\[] | `[]` | Paste thehub.io search or category URLs straight from your browser. When provided, the keyword and filters above are ignored. A URL with no recognizable filters collects a broad set of jobs. |
| `jobUrls` | string\[] | `[]` | Paste individual `thehub.io/jobs/<id>` URLs to scrape just those postings. If both `jobUrls` and `searchUrls` (or the keyword filters) are set, `jobUrls` takes precedence and only those postings are scraped. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Hard cap on total job rows returned. Set to `0` for no cap. The run keeps the full last page even if it slightly overshoots the cap. |

### Output

Every job is a single flat row. Key fields are flattened into table columns for easy filtering, while the nested `company`, `location`, `salaryRange`, and `views` objects are preserved in the full record.

```json
{
    "id": "63f1a2b4c8d9e0f1a2b3c4d5",
    "url": "https://thehub.io/jobs/63f1a2b4c8d9e0f1a2b3c4d5",
    "title": "Senior Backend Engineer",
    "descriptionText": "We're hiring a backend engineer to scale our payments platform...",
    "companyName": "Northbound Labs",
    "companyWebsite": "https://northboundlabs.io",
    "companyNumberOfEmployees": "11-50",
    "companyFounded": 2019,
    "company": {
        "name": "Northbound Labs",
        "website": "https://northboundlabs.io",
        "numberOfEmployees": "11-50",
        "founded": 2019,
        "whatWeDo": "Payments infrastructure for European fintechs.",
        "logoUrl": "https://thehub.io/api/companies/logo/abc123.png"
    },
    "address": "Vesterbrogade 1, Copenhagen",
    "locality": "Copenhagen",
    "country": "Denmark",
    "isRemote": true,
    "jobRole": "Software Engineering",
    "jobPositionTypes": ["Full-time"],
    "salary": "Monthly",
    "salaryMin": 55000,
    "salaryMax": 70000,
    "equity": "0.1% - 0.5%",
    "viewsWeek": 84,
    "viewsTotal": 1320,
    "applyLink": "https://northboundlabs.io/careers/backend-engineer",
    "applyEmail": null,
    "publishedAt": "2026-06-01T09:00:00Z",
    "expirationDate": "2026-07-15T00:00:00Z",
    "scrapedAt": "2026-06-24T14:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique job identifier on The Hub |
| `url` | string | Direct link to the job listing |
| `title` | string | Job title |
| `description` | string | Full job description (HTML) |
| `descriptionText` | string | Job description as plain text |
| `jobRole` | string | Role classification (e.g. Software Engineering) |
| `jobPositionTypes` | string\[] | Employment types (Full-time, Internship, etc.) |
| `isRemote` | boolean | Whether the job allows remote work |
| `scrapedAt` | string | ISO timestamp of when the row was collected |

#### Hiring Company

| Field | Type | Description |
|-------|------|-------------|
| `companyName` | string | Hiring company name |
| `companyWebsite` | string | Company website URL |
| `companyNumberOfEmployees` | string | Employee-count range (e.g. "11-50") |
| `companyFounded` | number | Year the company was founded |
| `company` | object | Full company object incl. `whatWeDo` blurb and `logoUrl` |

#### Location

| Field | Type | Description |
|-------|------|-------------|
| `address` | string | Full street address |
| `locality` | string | City |
| `country` | string | Country name |
| `location` | object | Nested `{ address, locality, country }` |

#### Compensation

| Field | Type | Description |
|-------|------|-------------|
| `salary` | string | Salary format as shown on the listing (e.g. "Monthly") |
| `salaryMin` | number | Minimum of the stated salary range |
| `salaryMax` | number | Maximum of the stated salary range |
| `salaryRange` | object | Nested `{ min, max }` |
| `equity` | string | Equity offer, when stated |

#### Engagement & Timestamps

| Field | Type | Description |
|-------|------|-------------|
| `viewsWeek` | number | Views in the last week |
| `viewsTotal` | number | All-time view count |
| `applyLink` | string | External link a candidate uses to apply |
| `applyEmail` | string | In-platform contact email used to apply when a job has no external apply link |
| `publishedAt` | string | When the listing was published |
| `expirationDate` | string | When the listing expires |
| `createdAt` | string | When the listing was created |

### Tips for Best Results

- **Leave filters blank to sweep everything** — with no region or position-type filter, the run scans all six countries plus the remote bucket and de-duplicates, giving you the full board in one pass.
- **Paste a pre-filtered URL for precise control** — set up exactly the filters you want in The Hub's own search UI, then paste that URL into `searchUrls`. It's the most reliable way to capture niche filter combinations.
- **Sort your results by `viewsWeek` to find hot roles** — high weekly views relative to age signal the postings candidates are actively clicking, ideal for sourcing where speed matters.
- **Use `companyNumberOfEmployees` and `companyFounded` to segment leads** — filter to young, fast-growing startups (recent founding year, small headcount) when building an early-stage sales list.
- **Start small, then scale** — run with `maxResults` at 50–100 first to confirm the filters match what you expect, then raise the cap for a full pull.
- **Combine a keyword with a single region** — pairing `searchQuery` with one country gives the tightest, most relevant set; broad keyword-only runs return the widest net.
- **`jobUrls` is exact** — when you already have specific posting links, drop them straight into `jobUrls` to skip search entirely and pull just those jobs. `jobUrls` always wins: if you set it alongside a keyword or `searchUrls`, only the listed postings are scraped and the search is skipped.

### Pricing

**From $3.00 per 1,000 results** — undercuts comparable Hub job extractors while bundling full company profiles, salary ranges, equity, and view counts at no extra charge. 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.36 | $0.34 | $0.32 | $0.30 |
| 1,000 | $3.60 | $3.40 | $3.20 | $3.00 |
| 10,000 | $36.00 | $34.00 | $32.00 | $30.00 |
| 100,000 | $360.00 | $340.00 | $320.00 | $300.00 |

A "result" is any job row in the output dataset. **No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.**

### 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 recruitment, talent sourcing, market research, and lead generation. Users are responsible for complying with applicable laws and The Hub's Terms of Service, and for handling any personal data in line with GDPR and other privacy regulations. Do not use extracted data for spam, harassment, or any illegal purpose.

# Actor input Schema

## `searchQuery` (type: `string`):

Job title, role, or skill to search for (e.g. 'software engineer', 'product manager', 'growth marketing'). Leave blank to collect all jobs matching the filters below.

## `regions` (type: `array`):

Only include jobs in these regions. Leave empty to include every region.

## `jobPositionTypes` (type: `array`):

Only include jobs of these employment types. Leave empty to include all types.

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

Turn on to return only jobs that allow remote work.

## `searchUrls` (type: `array`):

Paste thehub.io search or category URLs directly from your browser (e.g. https://thehub.io/jobs?search=engineer\&location=DK). Use this when you've already built filters in the site's UI. When provided, the keyword and filters above are ignored. If a URL has no recognizable filters (for example a typo'd link), the run falls back to a broad scan rather than failing.

## `jobUrls` (type: `array`):

Paste one or more individual job URLs to scrape just those listings (e.g. https://thehub.io/jobs/<id>). If both Job URLs and Search URLs (or the keyword filters above) are set, Job URLs take precedence and only these postings are scraped.

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

Hard cap on total job rows returned across all sources. Default 100 — increase for bigger runs, or set to 0 for no cap (an internal upper bound still applies to prevent runaway pagination). The actor stops requesting new pages once this number is hit but keeps the full last page even if it slightly overshoots.

## Actor input object example

```json
{
  "searchQuery": "software engineer",
  "regions": [],
  "jobPositionTypes": [],
  "remoteOnly": false,
  "searchUrls": [],
  "jobUrls": [],
  "maxResults": 100
}
```

# Actor output Schema

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

Table of jobs with the most useful fields — title, company, location, salary, remote flag, and link.

## `details` (type: `string`):

Full per-job rows with description, company info, salary range, equity, position types, and view counts.

# 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 = {
    "searchQuery": "software engineer",
    "regions": [],
    "jobPositionTypes": [],
    "searchUrls": [],
    "jobUrls": [],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/thehub-io-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 = {
    "searchQuery": "software engineer",
    "regions": [],
    "jobPositionTypes": [],
    "searchUrls": [],
    "jobUrls": [],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/thehub-io-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 '{
  "searchQuery": "software engineer",
  "regions": [],
  "jobPositionTypes": [],
  "searchUrls": [],
  "jobUrls": [],
  "maxResults": 100
}' |
apify call solidcode/thehub-io-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "The Hub Jobs Scraper",
        "description": "[💰 $3 / 1K] Extract startup job listings from thehub.io, the Nordic startup jobs board. Search by keyword, filter by region or position type, or paste job and search URLs. Returns title, company, location, salary range, equity, remote flag, view counts, and the apply link per job.",
        "version": "1.0",
        "x-build-id": "msr7TBh6hCeJzYDev"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~thehub-io-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-thehub-io-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~thehub-io-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-thehub-io-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~thehub-io-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-thehub-io-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": {
                    "searchQuery": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Job title, role, or skill to search for (e.g. 'software engineer', 'product manager', 'growth marketing'). Leave blank to collect all jobs matching the filters below."
                    },
                    "regions": {
                        "title": "Regions",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include jobs in these regions. Leave empty to include every region.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "DK",
                                "SE",
                                "NO",
                                "FI",
                                "IS",
                                "EU",
                                "REMOTE"
                            ],
                            "enumTitles": [
                                "Denmark",
                                "Sweden",
                                "Norway",
                                "Finland",
                                "Iceland",
                                "Europe (other)",
                                "Remote"
                            ]
                        },
                        "default": []
                    },
                    "jobPositionTypes": {
                        "title": "Position Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include jobs of these employment types. Leave empty to include all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Full-time",
                                "Part-time",
                                "Internship",
                                "Freelance",
                                "Cofounder",
                                "Student",
                                "Advisory board"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Part-time",
                                "Internship",
                                "Freelance",
                                "Cofounder",
                                "Student",
                                "Advisory board"
                            ]
                        },
                        "default": []
                    },
                    "remoteOnly": {
                        "title": "Remote jobs only",
                        "type": "boolean",
                        "description": "Turn on to return only jobs that allow remote work.",
                        "default": false
                    },
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Paste thehub.io search or category URLs directly from your browser (e.g. https://thehub.io/jobs?search=engineer&location=DK). Use this when you've already built filters in the site's UI. When provided, the keyword and filters above are ignored. If a URL has no recognizable filters (for example a typo'd link), the run falls back to a broad scan rather than failing.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobUrls": {
                        "title": "Job URLs",
                        "type": "array",
                        "description": "Paste one or more individual job URLs to scrape just those listings (e.g. https://thehub.io/jobs/<id>). If both Job URLs and Search URLs (or the keyword filters above) are set, Job URLs take precedence and only these postings are scraped.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on total job rows returned across all sources. Default 100 — increase for bigger runs, or set to 0 for no cap (an internal upper bound still applies to prevent runaway pagination). The actor stops requesting new pages once this number is hit but keeps the full last page even if it slightly overshoots.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
