# OpenStreetMap POI Extractor (`fetch_cat/openstreetmap-poi-extractor`) Actor

Extract public OpenStreetMap POIs by area and category for lead generation, market mapping, and site research.

- **URL**: https://apify.com/fetch\_cat/openstreetmap-poi-extractor.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Lead generation, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 poi saveds

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 POI Extractor

Extract public OpenStreetMap points of interest by area, category, and optional name keyword.

Use this Actor for local business lists, POI mapping, site-selection research, neighborhood amenity checks, travel datasets, and geospatial enrichment workflows.

### At a glance

- **Best for:** local POI exports, lead generation, market mapping, real-estate research, logistics planning, and public geospatial datasets.
- **Inputs:** bounding box or place name, amenity/shop/tourism tags, optional name keyword, raw tag toggle, and maximum POIs.
- **Outputs:** one OpenStreetMap object per row with name, category, coordinates, address, phone, website, opening hours, brand/operator, accessibility, and source URL when available.
- **Exports:** download CSV, JSON, Excel, XML, RSS, or use the Apify Dataset API.
- **Cost:** `$0.005` per run plus the `item` event for each saved POI row.

### Input recipes

Use these concrete input patterns when starting a new run:

- **Cafes in SoHo:** `{"placeName":"SoHo, New York, USA","amenityTags":["cafe"],"maxItems":25}`
- **Hotels near a district:** `{"bbox":"40.720,-74.005,40.730,-73.995","tourismTags":["hotel"],"maxItems":20}`
- **Supermarkets by bounding box:** `{"bbox":"51.500,-0.130,51.510,-0.110","shopTags":["supermarket"],"maxItems":50}`
- **Accessible restaurants with raw tags:** `{"placeName":"Mitte, Berlin, Germany","amenityTags":["restaurant"],"includeRawTags":true,"maxItems":30}`

### What can it do?

OpenStreetMap POI Extractor turns public OpenStreetMap places into a clean dataset.

- **Extract bounded OpenStreetMap POIs:** provide a small bounding box or place name and collect matching public OSM objects.
- **Filter by OSM categories:** use amenity, shop, and tourism tags such as `cafe`, `restaurant`, `supermarket`, `hotel`, or `museum`.
- **Collect contact and location fields:** save names, coordinates, category tags, address fields, phone, website, opening hours, and source URLs when available.
- **Inspect advanced tags:** enable `includeRawTags` when you need full OSM tag metadata for GIS or enrichment workflows.
- **Use as an OSM data API workflow:** run through Apify API, export CSV/Excel/JSON, schedule repeat extracts, or connect AI agents through Apify MCP.

### Who is it for?

- **Local lead generation teams:** build public prospect lists by area and category.
- **Site-selection teams:** compare neighborhood amenities.
- **Logistics teams:** map nearby services and pickup points.
- **Real-estate analysts:** research local surroundings and nearby services.
- **Market researchers:** compare category density by area.
- **Travel and mobility teams:** enrich maps with public POIs.

### Why use this actor?

OpenStreetMap is a strong alternative when you need public geographic data without scraping search engines or map apps.

This actor is designed for repeatable, bounded extraction jobs that produce structured rows you can export to CSV, Excel, JSON, Google Sheets, or an API pipeline.

### Output fields

| Field | Description |
| --- | --- |
| `osmId` | OpenStreetMap object ID |
| `osmType` | OSM object type: node, way, or relation |
| `name` | Place name when available |
| `categoryKey` | OSM category group such as amenity, shop, or tourism |
| `categoryValue` | OSM category value such as cafe or hotel |
| `lat` | Latitude |
| `lon` | Longitude |
| `address` | Human-friendly address assembled from common OSM tags |
| `city` | City, town, or village field |
| `postcode` | Postal code |
| `country` | Country code when present |
| `phone` | Phone/contact phone when present |
| `website` | Website/contact website when present |
| `openingHours` | OSM opening hours string |
| `brand` | Brand tag |
| `operator` | Operator tag |
| `wheelchair` | Wheelchair accessibility tag |
| `rawTags` | Optional raw OSM tags object |
| `sourceUrl` | Direct OpenStreetMap object URL |

### Pricing

The actor uses pay-per-event pricing.

You pay a small run-start fee and then a per-POI fee for saved dataset items.

Current pricing is $0.005 per run start plus tiered per-POI pricing. The BRONZE per-POI price is $0.000028052, with lower per-POI prices on higher usage tiers.

Use a small `maxItems` value for testing, then increase it once your category and area are correct.

### How to use it

1. Choose a small area.
2. Enter either a `bbox` (`south,west,north,east`) or a `placeName`.
3. Add one or more OSM tag values under amenity, shop, or tourism.
4. Optionally add a name keyword filter.
5. Set `maxItems`.
6. Run the actor.
7. Export the dataset or connect it to your workflow.

### Input configuration

| Setting | JSON key | What it does |
| --- | --- | --- |
| Bounding box | `bbox` | Exact area in `south,west,north,east` order. Best when you already know the coordinates. |
| Place name | `placeName` | Geocoded area name for quick tests or neighborhood-level extraction. Very large places may be rejected. |
| Amenity tags | `amenityTags` | OSM amenity values such as `cafe`, `restaurant`, `pharmacy`, `school`, `bank`, or `charging_station`. |
| Shop tags | `shopTags` | OSM shop values such as `supermarket`, `bakery`, `convenience`, `clothes`, or `hairdresser`. |
| Tourism tags | `tourismTags` | OSM tourism values such as `hotel`, `hostel`, `museum`, `attraction`, or `guest_house`. |
| Name keyword | `keyword` | Optional filter against OSM names. Useful for brand or chain searches. |
| Maximum POIs | `maxItems` | Maximum saved POI rows. The Actor enforces conservative limits for public OSM resources. |
| Include raw tags | `includeRawTags` | Adds the full raw OSM tag object when you need advanced metadata. |

#### Area input options

#### Bounding box

Use `bbox` when you already know the exact coordinates.

Example:

```json
{
  "bbox": "40.720,-74.005,40.730,-73.995"
}
````

The order is always:

```text
south,west,north,east
```

#### Place name

Use `placeName` for a quick test or neighborhood-level query.

Example:

```json
{
  "placeName": "SoHo, New York, USA"
}
```

Very large places may be rejected. Use a smaller area for reliable results.

#### Category input options

OpenStreetMap uses tags.

This actor supports three common POI tag groups:

- `amenityTags`
- `shopTags`
- `tourismTags`

Examples of `amenityTags`:

- `cafe`
- `restaurant`
- `pharmacy`
- `school`
- `bank`
- `bar`
- `charging_station`

Examples of `shopTags`:

- `supermarket`
- `bakery`
- `convenience`
- `clothes`
- `hairdresser`

Examples of `tourismTags`:

- `hotel`
- `hostel`
- `museum`
- `attraction`
- `guest_house`

### Example input

```json
{
  "bbox": "40.720,-74.005,40.730,-73.995",
  "amenityTags": ["cafe", "restaurant"],
  "shopTags": [],
  "tourismTags": [],
  "maxItems": 50,
  "includeRawTags": false
}
```

### Example output

```json
{
  "osmId": 123456789,
  "osmType": "node",
  "name": "Example Cafe",
  "categoryKey": "amenity",
  "categoryValue": "cafe",
  "lat": 40.7251,
  "lon": -74.0001,
  "address": "10 Example Street, New York 10001, US",
  "city": "New York",
  "postcode": "10001",
  "country": "US",
  "phone": "+1 555 0100",
  "website": "https://example.com",
  "openingHours": "Mo-Fr 08:00-18:00",
  "brand": null,
  "operator": null,
  "wheelchair": "yes",
  "sourceUrl": "https://www.openstreetmap.org/node/123456789"
}
```

### Tips for better results

- **Start with one or two categories:** confirm the tag values before adding a broader list.
- **Use a small area first:** neighborhood-level runs are more reliable than city-wide exports.
- **Use exact OSM tag values:** `cafe`, `restaurant`, and `supermarket` work better than free-form category names.
- **Increase `maxItems` gradually:** scale only after confirming the output shape.
- **Enable raw tags only when needed:** `includeRawTags` is useful for GIS workflows but makes rows heavier.

### Common workflows

- **Local lead lists:** extract cafes, restaurants, shops, or pharmacies in a target neighborhood.
- **Real-estate enrichment:** measure nearby services around a building, parcel, or rental area.
- **Market mapping:** compare the number and density of similar places across areas.
- **Logistics research:** find service points, fuel stations, convenience stores, or nearby amenities.

### Integrations

Use the dataset with:

- Google Sheets exports
- CSV and Excel workflows
- CRM enrichment pipelines
- BI dashboards
- Geospatial tools
- Apify API automations
- Webhooks after run completion

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/openstreetmap-poi-extractor').call({
  bbox: '40.720,-74.005,40.730,-73.995',
  amenityTags: ['cafe'],
  maxItems: 25
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/openstreetmap-poi-extractor').call(run_input={
    'bbox': '40.720,-74.005,40.730,-73.995',
    'amenityTags': ['cafe'],
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~openstreetmap-poi-extractor/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "bbox": "40.720,-74.005,40.730,-73.995",
    "amenityTags": ["cafe"],
    "maxItems": 25
  }'
```

### MCP and AI agents

Connect this Actor to AI tools through the official Apify MCP server. The default server can search and run Actors; the focused URL exposes only this Actor.

MCP URL:

```text
https://mcp.apify.com?tools=fetch_cat/openstreetmap-poi-extractor
```

Claude Code example:

```bash
claude mcp add --transport http apify-osm-pois "https://mcp.apify.com?tools=fetch_cat/openstreetmap-poi-extractor"
```

Claude Desktop example:

```json
{
  "mcpServers": {
    "apify-osm-pois": {
      "url": "https://mcp.apify.com?tools=fetch_cat/openstreetmap-poi-extractor"
    }
  }
}
```

Example prompts:

- "Find cafes in this bounding box and return a CSV-ready table."
- "Extract hotels around this district and summarize addresses and websites."
- "Compare supermarkets in two neighborhoods using separate actor runs."

### Limits and fair use

OpenStreetMap and Overpass are community resources.

This actor intentionally enforces conservative limits:

- Small bounding boxes only
- Maximum 1,000 saved POIs per run
- Short public API timeouts
- Limited retries

If you need very large OSM extracts, use official planet/regional extracts or your own Overpass infrastructure.

### Legality and attribution

This actor extracts public OpenStreetMap data.

OpenStreetMap data is available under the Open Database License (ODbL). You are responsible for complying with OSM attribution and share-alike requirements for your use case.

A practical attribution line is:

```text
OpenStreetMap contributors
```

Review the OpenStreetMap copyright and license pages before redistributing derived databases.

### Troubleshooting

#### Why did my run fail with a large bounding box?

The actor rejects large areas to protect public API resources and avoid expensive runs.

Use a smaller neighborhood-level bounding box or split the area into several runs.

#### Why are some fields empty?

OpenStreetMap is community-contributed data. Some POIs have complete address and contact tags; others only have names and coordinates.

Enable `includeRawTags` to inspect all available tags.

#### Why did I get fewer items than `maxItems`?

The selected area and categories may contain fewer matching POIs than your requested maximum.

Try a broader category or a nearby area.

### FAQ

#### Can this scrape Google Maps?

No. This actor extracts OpenStreetMap data only.

#### Can I search by brand name?

Yes. Use `keyword` to filter by the OSM `name` tag.

#### Can I extract hotels?

Yes. Add values such as `hotel`, `hostel`, or `guest_house` to `tourismTags`.

#### Can I extract supermarkets?

Yes. Add `supermarket` to `shopTags`.

#### Can I include all OSM tags?

Yes. Set `includeRawTags` to `true`.

### Related actors

- [Google News Scraper](https://apify.com/fetch_cat/google-news-scraper) - monitor local business or competitor news.
- [Yandex Maps Scraper](https://apify.com/fetch_cat/yandex-maps-scraper) - export public Yandex Maps business listings.
- [Website Contact Finder](https://apify.com/fetch_cat/website-contact-finder) - enrich website lists with public contact details.
- [Trustpilot Reviews Scraper](https://apify.com/fetch_cat/trustpilot-reviews-scraper) - export public business review data.

### Support

If a run fails, returns no data, or a field looks wrong, open an issue from the Actor page.

Please include the Apify run ID or run URL, input JSON, one example public URL, query, or input item, what you expected, and what the dataset returned. Small reproducible inputs make parsing or site-layout issues much faster to fix.

### Changelog

#### 0.1

Initial version with bounded OpenStreetMap POI extraction by area and category.

# Actor input Schema

## `placeName` (type: `string`):

Small area to geocode into a bounding box, for example a neighborhood or district. Large cities may be rejected if the bounding box is too large.

## `bbox` (type: `string`):

Optional south,west,north,east bounding box. Takes priority over place name when provided.

## `amenityTags` (type: `array`):

OpenStreetMap amenity values to extract, such as cafe, restaurant, pharmacy, school, bank, bar, or charging\_station.

## `shopTags` (type: `array`):

OpenStreetMap shop values to extract, such as supermarket, bakery, convenience, clothes, or hairdresser.

## `tourismTags` (type: `array`):

OpenStreetMap tourism values to extract, such as hotel, hostel, museum, attraction, or guest\_house.

## `keyword` (type: `string`):

Optional case-insensitive filter applied to the OSM name tag.

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

Maximum number of POIs to save. Keep this modest for public Overpass API fair use.

## `includeRawTags` (type: `boolean`):

Include the full raw OpenStreetMap tags object for each POI.

## `overpassEndpoint` (type: `string`):

Advanced: custom Overpass interpreter endpoint. Leave empty to use the public default.

## Actor input object example

```json
{
  "placeName": "SoHo, New York, USA",
  "bbox": "40.720,-74.005,40.730,-73.995",
  "amenityTags": [
    "cafe",
    "restaurant"
  ],
  "shopTags": [],
  "tourismTags": [],
  "maxItems": 20,
  "includeRawTags": false
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "placeName": "SoHo, New York, USA",
    "bbox": "40.720,-74.005,40.730,-73.995",
    "amenityTags": [
        "cafe",
        "restaurant"
    ],
    "shopTags": [],
    "tourismTags": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/openstreetmap-poi-extractor").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 = {
    "placeName": "SoHo, New York, USA",
    "bbox": "40.720,-74.005,40.730,-73.995",
    "amenityTags": [
        "cafe",
        "restaurant",
    ],
    "shopTags": [],
    "tourismTags": [],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/openstreetmap-poi-extractor").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 '{
  "placeName": "SoHo, New York, USA",
  "bbox": "40.720,-74.005,40.730,-73.995",
  "amenityTags": [
    "cafe",
    "restaurant"
  ],
  "shopTags": [],
  "tourismTags": []
}' |
apify call fetch_cat/openstreetmap-poi-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenStreetMap POI Extractor",
        "description": "Extract public OpenStreetMap POIs by area and category for lead generation, market mapping, and site research.",
        "version": "0.1",
        "x-build-id": "BGFjrxbG0sJm9sy2c"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~openstreetmap-poi-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-openstreetmap-poi-extractor",
                "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/fetch_cat~openstreetmap-poi-extractor/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-openstreetmap-poi-extractor",
                "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/fetch_cat~openstreetmap-poi-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-openstreetmap-poi-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "maxItems"
                ],
                "properties": {
                    "placeName": {
                        "title": "Place name",
                        "type": "string",
                        "description": "Small area to geocode into a bounding box, for example a neighborhood or district. Large cities may be rejected if the bounding box is too large."
                    },
                    "bbox": {
                        "title": "Bounding box",
                        "type": "string",
                        "description": "Optional south,west,north,east bounding box. Takes priority over place name when provided."
                    },
                    "amenityTags": {
                        "title": "Amenity tags",
                        "type": "array",
                        "description": "OpenStreetMap amenity values to extract, such as cafe, restaurant, pharmacy, school, bank, bar, or charging_station.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "shopTags": {
                        "title": "Shop tags",
                        "type": "array",
                        "description": "OpenStreetMap shop values to extract, such as supermarket, bakery, convenience, clothes, or hairdresser.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "tourismTags": {
                        "title": "Tourism tags",
                        "type": "array",
                        "description": "OpenStreetMap tourism values to extract, such as hotel, hostel, museum, attraction, or guest_house.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Name keyword filter",
                        "type": "string",
                        "description": "Optional case-insensitive filter applied to the OSM name tag."
                    },
                    "maxItems": {
                        "title": "Maximum POIs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of POIs to save. Keep this modest for public Overpass API fair use.",
                        "default": 20
                    },
                    "includeRawTags": {
                        "title": "Include raw OSM tags",
                        "type": "boolean",
                        "description": "Include the full raw OpenStreetMap tags object for each POI.",
                        "default": false
                    },
                    "overpassEndpoint": {
                        "title": "Overpass API endpoint",
                        "type": "string",
                        "description": "Advanced: custom Overpass interpreter endpoint. Leave empty to use the public default."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
