# Hotfrog Business Directory Scraper (`solidcode/hotfrog-scraper`) Actor

\[💰 $2.5 / 1K] Extract business listings from Hotfrog directories across 25+ countries — name, address, phone, website, email, coordinates, hours, categories, and social links. Search by category and city, browse cities, or paste profile URLs. Clean data for lead generation.

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

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Hotfrog Business Directory Scraper

Pull business listings from Hotfrog at scale — company names, full postal addresses, phone numbers, websites, map coordinates, and categories across 27 country directories. Search by category and city, browse a whole town, or paste Hotfrog URLs, and get one clean flat row per business. Built for lead-generation teams, local-market researchers, and sales prospectors who need structured directory data without copying listings out of Hotfrog one profile at a time.

### Why This Scraper?

- **27 country directories in one actor** — search Hotfrog across the United States, United Kingdom, Australia, Canada, Germany, France, Spain, Italy, India, Brazil, Japan, Hong Kong, Philippines, and 14 more, each with its own local listings and the correct local domain resolved for you.
- **Full postal address, split into fields** — street, city, state or region, postal code, and country arrive as separate columns, not one blob you have to parse apart.
- **Exact map coordinates on enriched profiles** — latitude and longitude on every detailed record, ready to drop onto a map or feed a radius search.
- **Direct phone and own-website link** — the company's real phone number, plus its own homepage URL (not a Hotfrog redirect) whenever the listing publishes one.
- **Three ways to target listings** — category-and-city search (e.g. "plumber" in "chicago"), whole-city browse that returns every business in a town, or paste exact Hotfrog search and company URLs.
- **Every search term crossed with every location** — list 5 categories and 10 cities and the actor runs all 50 combinations automatically, so one job covers a whole territory.
- **Business categories on every row** — the primary category plus the full list each business is filed under, so you can segment your list by trade or industry.
- **Up to 50,000 results per run** — sweep a single niche or hundreds of category-and-city pairs, with a fast shallow mode for volume and a full-detail mode for depth.

### Use Cases

**Lead Generation**
- Build call lists of local businesses by trade — plumbers, dentists, accountants, restaurants — with phone and website in every row
- Assemble territory-wide prospect lists by crossing many categories against many cities in one run
- Enrich a thin CRM with verified street addresses and postal codes
- Target a single high-value category across every city you serve

**Local Market Research**
- Map how many businesses of a given type operate in a city or region
- Compare business density across cities using componentized addresses and coordinates
- Track category coverage across all 27 country directories for international studies
- Plot businesses on a map with ready-to-use latitude and longitude

**Sales Prospecting**
- Pull fresh lists of businesses in your service area to feed outbound campaigns
- Segment prospects by primary category before your team ever picks up the phone
- Grab a company's own website so reps can research before outreach
- Refresh an existing prospect list on a schedule to catch new listings

**Competitive Analysis**
- List every competitor in a category and city, with contact details and location
- Benchmark your listing's completeness against others in the same category
- Monitor which businesses appear in a market over time
- Compare the same trade across multiple cities or countries

**Directory & Data Aggregation**
- Populate your own business directory or marketplace with structured Hotfrog records
- Standardize scattered listings into one flat, consistent schema
- Backfill company profiles with categories, coordinates, and addresses
- Combine search, city-browse, and URL inputs into a single unified dataset

### Getting Started

#### Category in a City (simplest)

Search one category in one city:

```json
{
    "searchTerms": ["restaurant"],
    "locations": ["new-york"],
    "country": "us"
}
````

#### Many Categories Across Many Cities

Every term is combined with every location — this runs 6 searches:

```json
{
    "searchTerms": ["plumber", "electrician", "dentist"],
    "locations": ["chicago", "boston"],
    "country": "us",
    "maxResults": 500
}
```

#### Whole-Country or Whole-City Browse

Leave `locations` empty to search a category nationwide, or leave `searchTerms` empty to grab every business in a city:

```json
{
    "searchTerms": ["accountant"],
    "locations": [],
    "country": "gb",
    "maxResults": 1000
}
```

#### Paste Hotfrog URLs

Paste search-result or company-profile URLs straight from your browser. When provided, the country, categories, and locations above are ignored:

```json
{
    "startUrls": [
        "https://www.hotfrog.com/find/plumber/new-york",
        "https://www.hotfrog.com/company/1a2b3c4d5e6f/bal4-ristorante/new-york/italian-restaurant"
    ],
    "maxResults": 200
}
```

#### Full Detail, Large Run

Turn on full detail for complete addresses, coordinates, and opening hours:

```json
{
    "searchTerms": ["dentist"],
    "locations": ["sydney", "melbourne"],
    "country": "au",
    "includeDetails": true,
    "maxResults": 2000
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | string\[] | `["restaurant"]` | Categories or keywords to look up (e.g. "plumber", "restaurant", "dentist"). Each term is searched in every location below. Leave empty to browse every business in the chosen locations. |
| `locations` | string\[] | `["new-york"]` | Cities or areas to search (e.g. "new-york", "los-angeles", "london"). Use hyphens for multi-word cities. Each location is combined with every search term. Leave empty to search the whole country. |
| `country` | select | `United States` | Which Hotfrog country directory to search. Each country has its own listings. See the 27 supported countries below. |

**Supported countries:** United States, United Kingdom, Australia, Canada, Ireland, New Zealand, Germany, France, Spain, Italy, Netherlands, Austria, Switzerland, Denmark, Norway, Poland, Portugal, India, Singapore, Malaysia, South Africa, Brazil, Mexico, Argentina, Japan, Hong Kong, Philippines.

#### Or Paste URLs

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Paste Hotfrog URLs directly — search-result pages or individual company profiles. When provided, the country, categories, and locations are ignored. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeDetails` | boolean | `true` | When on, opens each business's profile to add the complete record — exact coordinates, full opening hours, long description, and more. Turn off for a faster, lighter run that returns the core fields from the results list (name, profile URL, category, phone, partial address). |
| `maxResults` | integer | `100` | Hard cap on total business listings collected across all searches and URLs. A built-in ceiling of 50,000 applies to every run — any higher value (including 0, meaning "collect as much as possible") is capped at 50,000. Each listing is billed at the per-result rate. |

### Output

Each business is one flat row. Here's a representative result with full detail enabled:

```json
{
    "name": "Balciano Ristorante",
    "description": "Authentic Italian dining in Lower Manhattan — handmade pasta, wood-fired pizza, and a curated regional wine list.",
    "category": "Italian Restaurant",
    "categories": ["Italian Restaurant", "Restaurant", "Catering"],
    "phone": "+1 212-555-0182",
    "website": "https://www.balciano-ristorante.com",
    "email": null,
    "streetAddress": "96 Chambers St Frnt 102",
    "city": "New York",
    "state": "NY",
    "postalCode": "10007-2643",
    "addressCountry": "US",
    "latitude": 40.7145,
    "longitude": -74.0071,
    "openingHours": [
        { "dayOfWeek": "Monday", "opens": "11:30", "closes": "22:00" },
        { "dayOfWeek": "Tuesday", "opens": "11:30", "closes": "22:00" }
    ],
    "offers": [],
    "paymentAccepted": null,
    "socialLinks": [],
    "faqs": [],
    "image": "https://cdn.hotfrog.com/logos/balciano-ristorante.jpg",
    "images": ["https://cdn.hotfrog.com/logos/balciano-ristorante.jpg"],
    "addressSnippet": "96 Chambers St Frnt 102, New York, NY, 10007-2643",
    "searchTerm": "restaurant",
    "searchLocation": "new-york",
    "searchCountry": "us",
    "url": "https://www.hotfrog.com/company/1a2b3c4d5e6f/balciano-ristorante/new-york/italian-restaurant",
    "scrapedAt": "2026-07-15T14:30:00Z"
}
```

#### Core Business Fields

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Business name |
| `description` | string | Business description, when the listing has one |
| `category` | string | Primary business category |
| `categories` | string\[] | All categories the business is filed under |
| `image` | string | Logo or main image URL |
| `images` | string\[] | All image URLs found on the profile |
| `url` | string | Hotfrog company profile URL |

#### Address & Location

| Field | Type | Description |
|-------|------|-------------|
| `streetAddress` | string | Street address |
| `city` | string | City |
| `state` | string | State or region |
| `postalCode` | string | Postal or ZIP code |
| `addressCountry` | string | Country code |
| `latitude` | number | Latitude (full detail) |
| `longitude` | number | Longitude (full detail) |
| `addressSnippet` | string | Raw combined address line from the results card |

#### Contact & Web

| Field | Type | Description |
|-------|------|-------------|
| `phone` | string | Business phone number |
| `website` | string | The company's own website, when published |
| `email` | string | Public email address, when the business lists one directly |
| `socialLinks` | string\[] | Social profile links, when the business has published them |

#### Extra Details (when the business has published them)

| Field | Type | Description |
|-------|------|-------------|
| `openingHours` | object\[] | Opening hours per day (day, opens, closes) |
| `offers` | object\[] | Special offers or deals listed on the profile |
| `paymentAccepted` | string | Accepted payment methods |
| `faqs` | object\[] | Question-and-answer entries from the profile |

#### Search Provenance

| Field | Type | Description |
|-------|------|-------------|
| `searchTerm` | string | The category or keyword that produced this row |
| `searchLocation` | string | The location that produced this row |
| `searchCountry` | string | The country directory that produced this row |
| `scrapedAt` | string | ISO timestamp of when the record was collected |

### Tips for Best Results

- **Use hyphenated city slugs** — Hotfrog expects cities as URL slugs, so write "new-york", "los-angeles", and "san-francisco" (with hyphens), not "New York" with a space.
- **Match the country to the directory** — a London search returns nothing under `country: "us"`. Set `country` to "gb" for the UK, "au" for Australia, "de" for Germany, and so on; each country is a separate directory.
- **Keep detail on for full addresses and coordinates** — `includeDetails: true` opens each profile to add exact latitude, longitude, and the complete address. Turn it off only when you want a fast, lightweight sweep of names, categories, phones, and profile URLs.
- **Cross terms and cities to cover a territory** — because every term is combined with every location, a handful of categories against a handful of cities can build a whole regional list in one run.
- **Search the whole country when a category is niche** — leave `locations` empty to pull a category nationwide, or leave `searchTerms` empty to grab every business in a single city.
- **Start small, then scale** — set `maxResults` to 50–100 on your first run to confirm the categories and cities return what you expect, then raise the cap for the full pull.
- **Paste URLs for pinpoint targets** — when you already have a specific Hotfrog search or company page open, paste it into `startUrls` to skip the search fields entirely.

### Pricing

**From $2.50 per 1,000 results** — pay only for the business rows you receive, with Bronze, Silver, and Gold subscribers paying progressively less. The table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.30 | $0.29 | $0.27 | $0.25 |
| 1,000 | $3.00 | $2.85 | $2.65 | $2.50 |
| 10,000 | $30.00 | $28.50 | $26.50 | $25.00 |
| 100,000 | $300.00 | $285.00 | $265.00 | $250.00 |

A "result" is one business 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 business research, market analysis, and lead generation. You are responsible for complying with applicable laws and Hotfrog's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data in line with applicable privacy regulations such as GDPR and CCPA.

# Actor input Schema

## `searchTerms` (type: `array`):

Business categories or keywords to look up (e.g. 'plumber', 'restaurant', 'dentist', 'accountant'). Each term is searched in every location below, so you can cover many categories in one run. Leave empty to browse every business in the chosen locations instead.

## `locations` (type: `array`):

Cities or areas to search in (e.g. 'new-york', 'los-angeles', 'london', 'sydney'). Use hyphens for multi-word cities. Each location is combined with every search term above. Leave empty to search across the whole country.

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

Which Hotfrog country directory to search. Each country has its own listings.

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

Paste Hotfrog URLs directly from your browser — search result pages (e.g. https://www.hotfrog.com/find/plumber/new-york) or individual company profile pages (e.g. https://www.hotfrog.com/company/.../new-york/dental-care). When provided, the Country, Categories, and Locations above are ignored.

## `includeDetails` (type: `boolean`):

When enabled, the actor opens each business's profile page to add the complete record — email (when published), exact GPS coordinates, full opening hours, long description, offers/deals, payment methods, and social links. Turn this off for a faster, lighter run that returns just the core fields visible on the results list (name, profile URL, category, and partial address).

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

Hard cap on the total number of business listings collected across all searches and URLs. Default 100 — increase for bigger runs. A built-in safety ceiling of 50,000 results applies to every run: any higher value (including 0, which means 'collect as much as possible') is capped at 50,000. Each listing is billed at the per-result rate.

## Actor input object example

```json
{
  "searchTerms": [
    "restaurant"
  ],
  "locations": [
    "new-york"
  ],
  "country": "us",
  "startUrls": [],
  "includeDetails": true,
  "maxResults": 100
}
```

# Actor output Schema

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

Compact table of scraped businesses — name, category, phone, city, website, and profile link.

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

Full per-business rows including email, componentized address, coordinates, opening hours, offers, payment methods, and social links (populated when 'Include full business details' is on).

# 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 = {
    "searchTerms": [
        "restaurant"
    ],
    "locations": [
        "new-york"
    ],
    "country": "us",
    "startUrls": [],
    "includeDetails": true,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/hotfrog-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 = {
    "searchTerms": ["restaurant"],
    "locations": ["new-york"],
    "country": "us",
    "startUrls": [],
    "includeDetails": True,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/hotfrog-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 '{
  "searchTerms": [
    "restaurant"
  ],
  "locations": [
    "new-york"
  ],
  "country": "us",
  "startUrls": [],
  "includeDetails": true,
  "maxResults": 100
}' |
apify call solidcode/hotfrog-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hotfrog Business Directory Scraper",
        "description": "[💰 $2.5 / 1K] Extract business listings from Hotfrog directories across 25+ countries — name, address, phone, website, email, coordinates, hours, categories, and social links. Search by category and city, browse cities, or paste profile URLs. Clean data for lead generation.",
        "version": "1.0",
        "x-build-id": "hEzeAMdQyEUfsY72N"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~hotfrog-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-hotfrog-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~hotfrog-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-hotfrog-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~hotfrog-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-hotfrog-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": {
                    "searchTerms": {
                        "title": "Categories / Search Terms",
                        "type": "array",
                        "description": "Business categories or keywords to look up (e.g. 'plumber', 'restaurant', 'dentist', 'accountant'). Each term is searched in every location below, so you can cover many categories in one run. Leave empty to browse every business in the chosen locations instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities or areas to search in (e.g. 'new-york', 'los-angeles', 'london', 'sydney'). Use hyphens for multi-word cities. Each location is combined with every search term above. Leave empty to search across the whole country.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "us",
                            "gb",
                            "au",
                            "ca",
                            "ie",
                            "nz",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "at",
                            "ch",
                            "dk",
                            "no",
                            "pl",
                            "pt",
                            "in",
                            "sg",
                            "my",
                            "za",
                            "br",
                            "mx",
                            "ar",
                            "jp",
                            "hk",
                            "ph"
                        ],
                        "type": "string",
                        "description": "Which Hotfrog country directory to search. Each country has its own listings.",
                        "default": "us"
                    },
                    "startUrls": {
                        "title": "Hotfrog URLs",
                        "type": "array",
                        "description": "Paste Hotfrog URLs directly from your browser — search result pages (e.g. https://www.hotfrog.com/find/plumber/new-york) or individual company profile pages (e.g. https://www.hotfrog.com/company/.../new-york/dental-care). When provided, the Country, Categories, and Locations above are ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDetails": {
                        "title": "Include full business details",
                        "type": "boolean",
                        "description": "When enabled, the actor opens each business's profile page to add the complete record — email (when published), exact GPS coordinates, full opening hours, long description, offers/deals, payment methods, and social links. Turn this off for a faster, lighter run that returns just the core fields visible on the results list (name, profile URL, category, and partial address).",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on the total number of business listings collected across all searches and URLs. Default 100 — increase for bigger runs. A built-in safety ceiling of 50,000 results applies to every run: any higher value (including 0, which means 'collect as much as possible') is capped at 50,000. Each listing is billed at the per-result rate.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
