# OpenStreetMap Tourist Attractions Scraper (`automation-lab/openstreetmap-tourist-attractions-scraper`) Actor

Extract public tourist attractions from OpenStreetMap by city or bounding box, including categories, coordinates, contacts, websites, Wikidata and attribution.

- **URL**: https://apify.com/automation-lab/openstreetmap-tourist-attractions-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## OpenStreetMap Tourist Attractions Scraper

Extract public tourist attractions from OpenStreetMap by city, destination, region, or bounding box.

The actor returns normalized tourism POIs with OSM IDs, category, coordinates, address fields, website, phone, email, Wikidata, Wikipedia, opening hours, accessibility tags, and OpenStreetMap attribution.

Use it when you need an attraction database without browser automation, private accounts, or paid marketplace scraping.

### What does OpenStreetMap Tourist Attractions Scraper do?

OpenStreetMap Tourist Attractions Scraper queries public OpenStreetMap infrastructure for `tourism=*` points of interest.

It can geocode an area query such as `Paris, France` with Nominatim.

It can also accept an exact WGS84 bounding box for GIS workflows.

It then queries Overpass for tourism categories such as museums, attractions, viewpoints, galleries, zoos, aquariums, theme parks, artwork, and information points.

The final dataset is clean JSON that is ready for exports, enrichment, maps, lead lists, and destination analysis.

### Who is it for?

🏛️ Destination marketing teams can build attraction inventories for cities and regions.

🗺️ GIS analysts can enrich map layers with public OSM tourism data.

✈️ Travel-tech teams can seed local attraction databases for itinerary products.

📍 Local SEO teams can compare website/contact coverage across visitor attractions.

🧭 Tour operators can discover museums, viewpoints, landmarks, and visitor information points in new markets.

### Why use this actor?

OpenStreetMap is global, community-maintained, and openly licensed.

This actor focuses on public tourism POI data rather than reviews or booking pages.

It is HTTP/API based, so it is lightweight and avoids browser costs.

It includes OSM attribution and license metadata on every row.

It exposes raw tags optionally, so technical users can keep the long-tail OSM fields.

### Data returned

| Field | Description |
| --- | --- |
| `osmId` | Stable `node/123`, `way/123`, or `relation/123` identifier |
| `osmType` | OSM element type |
| `name` | Attraction name when tagged |
| `tourismCategory` | OSM `tourism=*` value |
| `latitude`, `longitude` | Point coordinates or Overpass center for ways/relations |
| `address` | Combined address from OSM tags |
| `website`, `phone`, `email` | Public contact tags when present |
| `wikidata`, `wikipedia` | Knowledge graph identifiers when present |
| `openingHours`, `fee`, `wheelchair` | Visitor/accessibility tags |
| `sourceUrl` | OpenStreetMap element URL |
| `attribution`, `license` | OSM attribution and ODbL note |

### How much does it cost to scrape OpenStreetMap tourist attractions?

The actor uses pay-per-event pricing.

There is a small start charge per run.

There is a per-attraction charge for each saved dataset item.

Current formula-derived pricing is $0.005 per run plus tiered per-result pricing.

Bronze per-attraction pricing is $0.00003053 per saved attraction, with Free at $0.000035109 and Diamond at $0.00001.

### Input options

Use `areaQuery` for simple destination searches.

Use `bbox` when you already have exact GIS coordinates.

Use `categories` to choose OSM tourism tag values.

Use `maxItems` to cap the dataset size.

Use `includeRawTags` to preserve the original OSM tag object.

Use `includeWaysAndRelations` when you want attractions mapped as areas, not only points.

### Example input: museums in Paris

```json
{
  "areaQuery": "Paris, France",
  "categories": ["museum", "gallery", "artwork"],
  "maxItems": 100,
  "includeWaysAndRelations": true,
  "includeRawTags": false
}
````

### Example input: exact bounding box

```json
{
  "bbox": "48.8156,2.2241,48.9022,2.4699",
  "categories": ["attraction", "viewpoint", "museum"],
  "maxItems": 250
}
```

### Example output

```json
{
  "osmId": "node/247618453",
  "osmType": "node",
  "name": "Musée des Arts et Métiers",
  "tourismCategory": "museum",
  "latitude": 48.8660977,
  "longitude": 2.3554138,
  "address": "60 Rue Réaumur, 75003",
  "website": "https://www.arts-et-metiers.net",
  "phone": "+33 1 53 01 82 20",
  "wikidata": "Q1538826",
  "wikipedia": "fr:Musée des arts et métiers",
  "sourceUrl": "https://www.openstreetmap.org/node/247618453",
  "attribution": "© OpenStreetMap contributors"
}
```

### Tips for better results

Start with a city or destination instead of a whole country.

Use a bounding box for large regions so the request stays predictable.

Keep `requestDelayMs` above 1000 ms for polite use of public APIs.

Add more categories only when you need them.

Turn on `includeRawTags` when you need niche OSM tags such as `operator`, `fee:conditional`, or `payment:*`.

### Common tourism categories

`attraction` covers general attractions.

`museum` covers museums.

`viewpoint` covers scenic viewpoints.

`gallery` covers galleries.

`theme_park` covers amusement parks.

`zoo` covers zoos.

`aquarium` covers aquariums.

`artwork` covers public art.

`information` covers visitor information features.

### Integrations

Send the dataset to Google Sheets for quick attraction audits.

Export JSON or CSV into a GIS pipeline.

Join `wikidata` IDs with Wikidata enrichments.

Use `sourceUrl` to let editors verify OSM elements.

Feed records into a destination content workflow.

Monitor the same bbox over time to detect new tagged attractions.

### 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('automation-lab/openstreetmap-tourist-attractions-scraper').call({
  areaQuery: 'Paris, France',
  categories: ['museum', 'attraction'],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/openstreetmap-tourist-attractions-scraper').call(run_input={
    'areaQuery': 'Rome, Italy',
    'categories': ['museum', 'viewpoint', 'attraction'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~openstreetmap-tourist-attractions-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"areaQuery":"London, United Kingdom","categories":["museum","attraction"],"maxItems":100}'
```

### MCP usage

Use the Apify MCP server with this actor enabled:

```bash
npx -y @apify/actors-mcp-server --actors automation-lab/openstreetmap-tourist-attractions-scraper
```

Claude Desktop / Claude Code MCP URL:

`https://mcp.apify.com/?tools=automation-lab/openstreetmap-tourist-attractions-scraper`

Claude Desktop JSON config example:

```json
{
  "mcpServers": {
    "apify-openstreetmap-tourist-attractions": {
      "url": "https://mcp.apify.com/?tools=automation-lab/openstreetmap-tourist-attractions-scraper"
    }
  }
}
```

Example prompt:

"Find up to 100 museums and viewpoints in Prague from OpenStreetMap and return website coverage gaps."

### Legality and attribution

This actor uses public OpenStreetMap-derived data.

OpenStreetMap data is licensed under the Open Database License.

Each result includes attribution and license metadata.

You are responsible for complying with OSM attribution requirements in your downstream product.

Do not overload public OSM services.

### Troubleshooting

If you get no results, try a smaller area or different tourism categories.

If geocoding fails, use `bbox` directly.

If an Overpass endpoint is busy, the actor automatically tries fallback endpoints.

If a website or phone is missing, it probably is not tagged in OpenStreetMap.

### Related scrapers

Use `https://apify.com/automation-lab/google-maps-lead-finder` when you need business listings and commercial lead enrichment.

Use `https://apify.com/automation-lab/website-contact-finder` when you already have attraction websites and need contact discovery.

Use this actor when public OSM tourism coverage is enough and you want open-data attribution.

### FAQ

#### Can I scrape restaurants with this actor?

No. This actor targets OSM `tourism=*` tags. Restaurants usually use `amenity=restaurant` and are outside the MVP.

#### Does it return reviews?

No. OpenStreetMap does not provide review content.

#### Does it require proxies?

No. The actor uses public OSM APIs with polite delays.

#### Can I use a custom Overpass endpoint?

Yes. Set `overpassEndpoint` and optional `fallbackOverpassEndpoints`.

#### Why are some attractions unnamed?

Some OSM elements have a tourism tag but no `name` tag. The actor keeps them when they are valid tourism POIs.

# Actor input Schema

## `areaQuery` (type: `string`):

Place name to geocode with Nominatim, for example 'Paris, France' or 'Rome historic center'.

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

Optional WGS84 box as 'south,west,north,east'. Overrides area query when supplied.

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

OpenStreetMap tourism tag values such as museum, attraction, viewpoint, gallery, zoo, aquarium, theme\_park, artwork, information.

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

Maximum records to save to the dataset.

## `includeWaysAndRelations` (type: `boolean`):

Include OSM ways and relations in addition to nodes. Recommended for museums, parks, zoos, and landmark areas.

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

Attach the original OSM tag object to each result for GIS/enrichment workflows.

## `requestDelayMs` (type: `integer`):

Polite delay between public OSM/Nominatim/Overpass API calls.

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

Advanced: custom Overpass API interpreter endpoint.

## `fallbackOverpassEndpoints` (type: `array`):

Advanced: additional Overpass interpreter endpoints to try if the primary endpoint is unavailable.

## Actor input object example

```json
{
  "areaQuery": "Paris, France",
  "bbox": "48.8156,2.2241,48.9022,2.4699",
  "categories": [
    "museum",
    "attraction",
    "viewpoint",
    "gallery"
  ],
  "maxItems": 20,
  "includeWaysAndRelations": true,
  "includeRawTags": false,
  "requestDelayMs": 1100,
  "overpassEndpoint": "https://maps.mail.ru/osm/tools/overpass/api/interpreter",
  "fallbackOverpassEndpoints": [
    "https://overpass-api.de/api/interpreter",
    "https://overpass.kumi.systems/api/interpreter"
  ]
}
```

# 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 = {
    "areaQuery": "Paris, France",
    "bbox": "48.8156,2.2241,48.9022,2.4699",
    "categories": [
        "museum",
        "attraction",
        "viewpoint",
        "gallery"
    ],
    "maxItems": 20,
    "includeWaysAndRelations": true,
    "includeRawTags": false,
    "requestDelayMs": 1100,
    "overpassEndpoint": "https://maps.mail.ru/osm/tools/overpass/api/interpreter",
    "fallbackOverpassEndpoints": [
        "https://overpass-api.de/api/interpreter",
        "https://overpass.kumi.systems/api/interpreter"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/openstreetmap-tourist-attractions-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 = {
    "areaQuery": "Paris, France",
    "bbox": "48.8156,2.2241,48.9022,2.4699",
    "categories": [
        "museum",
        "attraction",
        "viewpoint",
        "gallery",
    ],
    "maxItems": 20,
    "includeWaysAndRelations": True,
    "includeRawTags": False,
    "requestDelayMs": 1100,
    "overpassEndpoint": "https://maps.mail.ru/osm/tools/overpass/api/interpreter",
    "fallbackOverpassEndpoints": [
        "https://overpass-api.de/api/interpreter",
        "https://overpass.kumi.systems/api/interpreter",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/openstreetmap-tourist-attractions-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 '{
  "areaQuery": "Paris, France",
  "bbox": "48.8156,2.2241,48.9022,2.4699",
  "categories": [
    "museum",
    "attraction",
    "viewpoint",
    "gallery"
  ],
  "maxItems": 20,
  "includeWaysAndRelations": true,
  "includeRawTags": false,
  "requestDelayMs": 1100,
  "overpassEndpoint": "https://maps.mail.ru/osm/tools/overpass/api/interpreter",
  "fallbackOverpassEndpoints": [
    "https://overpass-api.de/api/interpreter",
    "https://overpass.kumi.systems/api/interpreter"
  ]
}' |
apify call automation-lab/openstreetmap-tourist-attractions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenStreetMap Tourist Attractions Scraper",
        "description": "Extract public tourist attractions from OpenStreetMap by city or bounding box, including categories, coordinates, contacts, websites, Wikidata and attribution.",
        "version": "0.1",
        "x-build-id": "FoOlfXB8V1UUMkOxG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~openstreetmap-tourist-attractions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-openstreetmap-tourist-attractions-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/automation-lab~openstreetmap-tourist-attractions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-openstreetmap-tourist-attractions-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/automation-lab~openstreetmap-tourist-attractions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-openstreetmap-tourist-attractions-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": {
                    "areaQuery": {
                        "title": "🗺️ Area query",
                        "type": "string",
                        "description": "Place name to geocode with Nominatim, for example 'Paris, France' or 'Rome historic center'."
                    },
                    "bbox": {
                        "title": "Bounding box",
                        "type": "string",
                        "description": "Optional WGS84 box as 'south,west,north,east'. Overrides area query when supplied."
                    },
                    "categories": {
                        "title": "Tourism categories",
                        "type": "array",
                        "description": "OpenStreetMap tourism tag values such as museum, attraction, viewpoint, gallery, zoo, aquarium, theme_park, artwork, information.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "attraction",
                            "museum",
                            "viewpoint",
                            "gallery",
                            "theme_park",
                            "zoo",
                            "aquarium",
                            "artwork",
                            "information"
                        ]
                    },
                    "maxItems": {
                        "title": "Maximum attractions",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum records to save to the dataset.",
                        "default": 100
                    },
                    "includeWaysAndRelations": {
                        "title": "Include areas and relations",
                        "type": "boolean",
                        "description": "Include OSM ways and relations in addition to nodes. Recommended for museums, parks, zoos, and landmark areas.",
                        "default": true
                    },
                    "includeRawTags": {
                        "title": "Include raw OSM tags",
                        "type": "boolean",
                        "description": "Attach the original OSM tag object to each result for GIS/enrichment workflows.",
                        "default": false
                    },
                    "requestDelayMs": {
                        "title": "Request delay (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay between public OSM/Nominatim/Overpass API calls.",
                        "default": 1100
                    },
                    "overpassEndpoint": {
                        "title": "Primary Overpass endpoint",
                        "type": "string",
                        "description": "Advanced: custom Overpass API interpreter endpoint."
                    },
                    "fallbackOverpassEndpoints": {
                        "title": "Fallback Overpass endpoints",
                        "type": "array",
                        "description": "Advanced: additional Overpass interpreter endpoints to try if the primary endpoint is unavailable.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```