# OpenStreetMap Places Scraper – POI & Local Business Data (`dataquarry/osm-places-scraper`) Actor

Extract clean POI / local business data from OpenStreetMap by area and category. No Overpass QL, no API key; data is open (ODbL) and legally redistributable.

- **URL**: https://apify.com/dataquarry/osm-places-scraper.md
- **Developed by:** [Daniel Brenner](https://apify.com/dataquarry) (community)
- **Categories:** Lead generation, Travel, Real estate
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, NaN 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.

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

## OpenStreetMap Places Scraper – POI & Local Business Data

Extract clean, structured **local business / POI data from OpenStreetMap** by area and category — **no Overpass query language, no API key, no anti-bot battles**. A legal, open-data alternative to Google Maps scrapers.

Give it an area like `"Berlin, Germany"` and categories like `["restaurant", "cafe"]`, and get back tidy rows: name, brand, address, coordinates, phone, email, website, opening hours, cuisine, and the full OpenStreetMap tag set. You can also **search by name** (find every `"Starbucks"` or all `"Aldi"` supermarkets in a city) or **search around a point** (every café within 800 m of a hotel).

### Why use this scraper?

- **Legal & open.** OpenStreetMap data is licensed under the ODbL — you can redistribute it (with attribution). No Terms-of-Service violations and no scraping behind logins.
- **No API key, no setup.** Just give it an area and the categories you want.
- **Global coverage.** Anywhere OpenStreetMap has data — worldwide.
- **Search by area, radius, or name.** A whole city/region, everything within X metres of a point, or every location of a brand.
- **Clean, flat output.** Ready for CSV / Excel / JSON, plus the raw OSM tags when you need more detail.
- **No Overpass QL required.** It builds and runs the query for you.
- **No duplicates.** When OpenStreetMap maps one place twice (a node and a building outline), you get a single, richer row — not two.
- **Honest data.** Every value comes straight from OpenStreetMap; a field that isn't mapped is left empty (`null`) — never guessed or padded.
- **Reliable.** Automatically retries across multiple Overpass mirrors to handle transient timeouts.

### What you can extract

**115+ place categories** across food & drink, retail shops, hotels & lodging, health & beauty, finance, automotive (including **EV charging stations**), education, public services, leisure, tourism & attractions, professional offices, and trades — restaurants, cafés, bars, hotels, supermarkets, pharmacies, dentists, banks, fuel stations, museums, real-estate agents and many more (full list below). Great for:

- Local business / POI datasets for analysis, lead generation, or store-locator features
- Market research, competitor mapping, and location intelligence
- Real-estate, retail site selection, and territory planning
- Feeding AI / RAG pipelines with structured place data
- A clean, legal alternative to "Google Maps scraper" tools

#### Common uses

- "Get every restaurant / café / bar in a city" for a directory or delivery app
- "List all dentists / doctors / pharmacies in a region" for healthcare outreach
- "Export EV charging stations and fuel stations" for mobility products
- "Find real-estate agents, lawyers, or accountants" for B2B lead lists
- "Map hotels, museums, and attractions" for travel and tourism datasets

### Input

| Field | Type | Description |
|---|---|---|
| `area` | string | Place to search within, e.g. `"Berlin, Germany"`. Geocoded to a bounding box via Nominatim. |
| `categories` | array | Place categories to extract, e.g. `["restaurant","cafe","hotel"]`. |
| `searchTerm` | string | *(optional)* Only return places whose **name** contains this text (case-insensitive), e.g. `"Starbucks"`. Combine with `categories` to narrow (supermarkets named `"Aldi"`), or use alone to find a brand across all place types. |
| `aroundLocation` | string | *(optional)* An address or place to search **around** within a radius, e.g. `"Times Square, New York"`. Geocoded to a center point; pair with `radiusMeters`. |
| `radiusMeters` | integer | *(optional)* Radius in meters for the around-a-location search (default `1000`). |
| `centerPoint` | object | *(advanced)* Explicit center `{ "lat":.., "lon":.. }` to search around. Overrides `aroundLocation`. |
| `maxResults` | integer | Maximum number of POIs to return (default `1000`). |
| `boundingBox` | object | *(advanced)* Explicit `{ "south":.., "west":.., "north":.., "east":.. }`. Overrides `area` when set. |

**Choosing a search area:** use **`area`** for a whole city/region (bounding box), or **`aroundLocation` + `radiusMeters`** for everything within X meters of a point (e.g. "cafés within 1 km of a hotel"). `boundingBox` and `centerPoint` are explicit-coordinate alternatives.

#### Example input

```json
{
  "area": "Heidelberg, Germany",
  "categories": ["cafe", "restaurant"],
  "maxResults": 200
}
````

To find every location of a brand, use `searchTerm` (with or without categories):

```json
{
  "area": "Berlin, Germany",
  "categories": ["supermarket"],
  "searchTerm": "Aldi"
}
```

To find places **within a radius** of a point, use `aroundLocation` + `radiusMeters`:

```json
{
  "aroundLocation": "Times Square, New York",
  "categories": ["cafe", "restaurant"],
  "radiusMeters": 800
}
```

### Output

One row per place:

| Field | Description |
|---|---|
| `name` | Place name |
| `category` | Primary category (e.g. `cafe`, `lawyer`, `charging_station`) |
| `brand` | Brand / chain name when tagged — useful for competitor & chain mapping |
| `brand_wikidata` | Wikidata id of the brand (e.g. `Q38076`) — a stable entity id for brand / market-share analysis |
| `brand_logo` | Official brand logo image URL (from the brand's Wikidata entry) when one exists — handy for directories/UIs; null otherwise |
| `latitude`, `longitude` | Coordinates |
| `street`, `housenumber`, `city`, `postcode`, `country` | Address parts (see *Field coverage* below for fallbacks) |
| `phone`, `email`, `website`, `opening_hours` | Contact details and hours |
| `cuisine` | Cuisine type(s) for food places, e.g. `italian;pizza` |
| `operator` | Who operates the place (chains, councils, franchises) |
| `wheelchair` | Accessibility: `yes` / `no` / `limited` |
| `osm_id`, `osm_type` | OpenStreetMap identifiers |
| `all_tags` | Full raw OpenStreetMap tag object |
| `source_url` | Link to the element on openstreetmap.org |
| `full_address` | All present address parts in one string (e.g. `Main St 1, 10115 Berlin`) — convenient for CRM/mail-merge |
| `map_url` | Google Maps link to the coordinates |

#### Example output

```json
{
  "name": "Cafe Frisch",
  "category": "cafe",
  "brand": null,
  "latitude": 49.4128139,
  "longitude": 8.678372,
  "street": "Jahnstraße",
  "housenumber": "34",
  "city": "Heidelberg",
  "postcode": "69120",
  "phone": null,
  "email": null,
  "website": "https://www.cafe-frisch.de",
  "opening_hours": "Mo-Fr 06:00-18:00; Sa 06:00-12:00; Su,PH 08:00-17:00",
  "cuisine": "coffee_shop",
  "operator": null,
  "wheelchair": "yes",
  "osm_id": 305963168,
  "osm_type": "node",
  "source_url": "https://www.openstreetmap.org/node/305963168"
}
```

Any field is `null` when the place hasn't tagged it in OpenStreetMap. `brand` and `email` are populated for many chains and businesses (coverage varies by region) — and `all_tags` always carries every raw tag if you need more.

#### Field coverage

OpenStreetMap is community-mapped, so coverage varies by place and region. To maximise filled fields **without ever inventing data**, several fields fall back to alternate OSM tags on the *same record*:

- `street` → `addr:street`, else `addr:place`
- `housenumber` → `addr:housenumber`, else `addr:housename`
- `city` → `addr:city`, else `addr:town` / `addr:village` / `addr:suburb` / `addr:municipality` / `addr:hamlet`
- `postcode` → `addr:postcode`, else `postal_code`
- `website` → `website`, else `contact:website` / `url` / `contact:url`
- `phone` → `phone`, else `contact:phone` / `contact:mobile`
- `email` → `email`, else `contact:email`
- `country` → the place's own `addr:country` / `addr:country_code` when present; otherwise the **country of the area you searched** (an `area` / `aroundLocation` name resolved via Nominatim). Raw `boundingBox` / `centerPoint` searches don't fill it.
- `state` → `addr:state`, else `addr:province` (common in the US / Canada / Australia; `null` where not tagged)
- `branch` → a chain outlet's branch/location name (OSM `branch`), e.g. `"Times Square"` for a specific Starbucks; `null` when not a tagged branch

Every value comes straight from OpenStreetMap (or, for the `country` fallback, from the geocoded area you searched). **Fields that aren't mapped stay `null` — this scraper never guesses or fabricates a value.**

### Supported categories

Pass any of these in `categories` (use the exact key). 115+ categories grouped by theme:

**Food & drink:** `restaurant`, `cafe`, `bar`, `pub`, `fast_food`, `food_court`, `ice_cream`, `biergarten`

**Lodging:** `hotel`, `hostel`, `guest_house`, `motel`, `apartment`, `camp_site`

**Groceries & food shops:** `supermarket`, `convenience`, `bakery`, `butcher`, `greengrocer`, `deli`, `confectionery`, `beverages`, `alcohol`, `kiosk`, `marketplace`

**Retail:** `clothes`, `shoes`, `jewelry`, `books`, `stationery`, `gift`, `toys`, `furniture`, `electronics`, `computer`, `mobile_phone`, `hardware`, `doityourself`, `garden_centre`, `florist`, `sports`, `outdoor`, `bicycle`, `pet`, `optician`, `variety_store`, `department_store`, `mall`, `tobacco`

**Health & beauty:** `pharmacy`, `chemist`, `hospital`, `clinic`, `doctors`, `dentist`, `veterinary`, `beauty`, `cosmetics`, `hairdresser`

**Services:** `laundry`, `dry_cleaning`, `travel_agency`

**Finance:** `bank`, `atm`, `bureau_de_change`

**Automotive & transport:** `fuel`, `charging_station`, `parking`, `car`, `car_repair`, `car_parts`, `car_rental`, `car_wash`, `taxi`, `bicycle_rental`

**Education:** `school`, `university`, `college`, `kindergarten`, `library`, `driving_school`, `language_school`

**Public & civic:** `post_office`, `police`, `fire_station`, `townhall`, `courthouse`, `place_of_worship`, `community_centre`

**Leisure, sport & tourism:** `gym`, `sports_centre`, `swimming_pool`, `stadium`, `golf_course`, `park`, `playground`, `marina`, `cinema`, `theatre`, `nightclub`, `museum`, `gallery`, `attraction`, `theme_park`, `zoo`, `viewpoint`

**Offices (B2B):** `estate_agent`, `lawyer`, `accountant`, `insurance`, `architect`, `it`, `employment_agency`, `company`, `coworking`

**Trades:** `electrician`, `plumber`, `carpenter`, `painter`

More OpenStreetMap categories can be added on request.

### FAQ

**Do I need an API key or account?**
No — give it an area (plus optional categories/filters) and run. No data-provider key, no quota, no setup.

**Is the data legal to use and redistribute?**
Yes. It comes from OpenStreetMap under the Open Database License (ODbL): public data you can redistribute with attribution (© OpenStreetMap contributors). No logins, no Terms-of-Service violations.

**How is this different from a Google Maps scraper?**
It uses open OpenStreetMap data instead of scraping a site behind anti-bot defenses and Terms of Service — so it's legal, needs no API key, and returns an honest `null` for anything OSM hasn't mapped instead of guessing.

**How much does it cost?**
Pay-per-result: **$3 per 1,000 results** — you only pay for the rows you actually get.

**Which countries does it cover?**
Worldwide — anywhere OpenStreetMap has data.

**How fresh is the data?**
It's pulled live from OpenStreetMap at run time, so it reflects the current map.

### Data source & license

Data comes from **OpenStreetMap** via the public **Nominatim** (geocoding) and **Overpass** (querying) APIs. OpenStreetMap data is **© OpenStreetMap contributors** and licensed under the **Open Database License (ODbL)**. If you publish or redistribute results, please attribute "© OpenStreetMap contributors".

### Notes

- Coverage and detail vary by region — OpenStreetMap is community-mapped, so dense urban areas are richer than remote ones.
- Larger areas + many categories return more results and take longer; use `maxResults` to cap output.

### More OpenStreetMap data actors

Part of **dataquarry**'s family of clean, ODbL OpenStreetMap extractors — same flexible **area / radius / bounding-box / name** search, same honest-null data (a field that isn't mapped is left empty, never guessed):

- [OpenStreetMap Places Scraper](https://apify.com/dataquarry/osm-places-scraper) — POI & local business, 115+ categories
- [EV Charging Stations Scraper](https://apify.com/dataquarry/ev-charging-stations) — socket types, power (kW), networks
- [Hotels & Lodging Scraper](https://apify.com/dataquarry/hotels-lodging) — stars, rooms, brands
- [Healthcare Facilities Scraper](https://apify.com/dataquarry/healthcare-facilities) — pharmacies, doctors, dentists, clinics
- [Tourist Attractions & Museums Scraper](https://apify.com/dataquarry/tourist-attractions) — Wikidata & Wikipedia links
- [Fuel Station Scraper](https://apify.com/dataquarry/fuel-stations) — fuel types, brands, payment methods
- [Supermarket & Grocery Scraper](https://apify.com/dataquarry/supermarkets) — brands, organic, payment methods

# Actor input Schema

## `area` (type: `string`):

Place name to search within, e.g. "Berlin, Germany". Geocoded to a bounding box via Nominatim. Provide this OR a bounding box.

## `boundingBox` (type: `object`):

Explicit bounding box as {"south":..,"west":..,"north":..,"east":..}. Overrides Area when set.

## `categories` (type: `array`):

Place categories to extract (use the exact key). 115+ supported across food & drink, retail, lodging, health, finance, automotive (incl. charging\_station for EV), education, public services, leisure, tourism, offices and trades. Examples: restaurant, cafe, hotel, supermarket, pharmacy, dentist, bank, charging\_station, museum, estate\_agent. Full list in the README.

## `searchTerm` (type: `string`):

Optional. Only return places whose name contains this text (case-insensitive), e.g. "Starbucks" or "Aldi". Combine with categories to narrow (e.g. supermarkets named "Aldi"), or use it alone to find a brand across all place types.

## `aroundLocation` (type: `string`):

Optional. An address or place name to search AROUND within a radius, e.g. "Times Square, New York". Geocoded to a center point; set the radius with "radiusMeters". Use this instead of Area for point-and-radius searches.

## `centerPoint` (type: `object`):

Optional advanced alternative to Area Location: an explicit center as {"lat":.., "lon":..} to search around. Overrides aroundLocation when set.

## `radiusMeters` (type: `integer`):

Radius in meters for the around-a-location search (used with Around Location or Center Point). Default 1000.

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

Maximum number of POIs to return.

## Actor input object example

```json
{
  "area": "Heidelberg, Germany",
  "categories": [
    "cafe"
  ],
  "radiusMeters": 1000,
  "maxResults": 1000
}
```

# 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 = {
    "area": "Heidelberg, Germany",
    "categories": [
        "cafe"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataquarry/osm-places-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 = {
    "area": "Heidelberg, Germany",
    "categories": ["cafe"],
}

# Run the Actor and wait for it to finish
run = client.actor("dataquarry/osm-places-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 '{
  "area": "Heidelberg, Germany",
  "categories": [
    "cafe"
  ]
}' |
apify call dataquarry/osm-places-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenStreetMap Places Scraper – POI & Local Business Data",
        "description": "Extract clean POI / local business data from OpenStreetMap by area and category. No Overpass QL, no API key; data is open (ODbL) and legally redistributable.",
        "version": "0.0",
        "x-build-id": "aT6TZt8M8HGPMOh8V"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dataquarry~osm-places-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dataquarry-osm-places-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/dataquarry~osm-places-scraper/runs": {
            "post": {
                "operationId": "runs-sync-dataquarry-osm-places-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/dataquarry~osm-places-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-dataquarry-osm-places-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": {
                    "area": {
                        "title": "Area",
                        "type": "string",
                        "description": "Place name to search within, e.g. \"Berlin, Germany\". Geocoded to a bounding box via Nominatim. Provide this OR a bounding box."
                    },
                    "boundingBox": {
                        "title": "Bounding box (advanced)",
                        "type": "object",
                        "description": "Explicit bounding box as {\"south\":..,\"west\":..,\"north\":..,\"east\":..}. Overrides Area when set."
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Place categories to extract (use the exact key). 115+ supported across food & drink, retail, lodging, health, finance, automotive (incl. charging_station for EV), education, public services, leisure, tourism, offices and trades. Examples: restaurant, cafe, hotel, supermarket, pharmacy, dentist, bank, charging_station, museum, estate_agent. Full list in the README.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerm": {
                        "title": "Search by name (optional)",
                        "type": "string",
                        "description": "Optional. Only return places whose name contains this text (case-insensitive), e.g. \"Starbucks\" or \"Aldi\". Combine with categories to narrow (e.g. supermarkets named \"Aldi\"), or use it alone to find a brand across all place types."
                    },
                    "aroundLocation": {
                        "title": "Search around a location (radius)",
                        "type": "string",
                        "description": "Optional. An address or place name to search AROUND within a radius, e.g. \"Times Square, New York\". Geocoded to a center point; set the radius with \"radiusMeters\". Use this instead of Area for point-and-radius searches."
                    },
                    "centerPoint": {
                        "title": "Center point (advanced radius)",
                        "type": "object",
                        "description": "Optional advanced alternative to Area Location: an explicit center as {\"lat\":.., \"lon\":..} to search around. Overrides aroundLocation when set."
                    },
                    "radiusMeters": {
                        "title": "Radius (meters)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Radius in meters for the around-a-location search (used with Around Location or Center Point). Default 1000.",
                        "default": 1000
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of POIs to return.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```