# 10times Trade Shows & Events Scraper (`automation-lab/10times-events-scraper`) Actor

Scrapes B2B trade shows, conferences, and events from 10times.com including event details, dates, venues, and organizer information

- **URL**: https://apify.com/automation-lab/10times-events-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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

## 10times Trade Shows & Events Scraper

Scrape B2B trade shows, conferences, summits, and exhibitions from [10times.com](https://10times.com) — the world's largest event discovery platform with 200,000+ events across 100+ industries. Extract event names, dates, venues, attendee estimates, exhibitor counts, and industry tags.

### What does 10times Trade Shows & Events Scraper do?

This actor fetches listing pages from 10times.com by city/industry URL or keyword search and extracts structured event data. For each event, it collects:

- **Event info**: name, URL, edition number, description
- **Dates**: start and end dates (ISO format)
- **Location**: city, country
- **Audience metrics**: estimated attendees and exhibitors (when shown)
- **Industry tags**: event type (Tradeshow, Conference, etc.) and topic tags
- **Images**: event cover image URL

### Who is it for

- **Sales & BDR teams** — find trade shows where target buyers exhibit; build outreach lists before registration closes
- **Event marketers** — discover sponsorship and speaking opportunities by industry and location
- **Market intelligence analysts** — track event frequency and venue trends across industries
- **Lead generation agencies** — export event organizer and exhibitor data for campaigns
- **Competitive intelligence** — monitor competitor presence at industry conferences
- **Researchers & journalists** — map the global conference landscape

### Why use 10times Trade Shows & Events Scraper?

- **Massive coverage** — 10times.com lists 200,000+ events globally across pharma, tech, fintech, manufacturing, healthcare, and more
- **B2B focus** — trade shows and industry conferences; ideal for sales and market research
- **Flexible input** — browse by location+category URL or keyword search
- **Pagination** — automatically pages through results up to your `maxResults` limit
- **Structured output** — clean JSON ready for CRM import, lead enrichment, or competitive analysis

### Use cases

- **Sales prospecting**: Find trade shows in your target vertical and reach out to exhibitors or organizers
- **Market intelligence**: Track which industries are hosting the most events and where
- **Lead generation**: Build lists of events for outreach campaigns
- **Competitive research**: Monitor competitor presence at industry conferences
- **Event marketing**: Identify speaking and sponsorship opportunities by category
- **Partnership sourcing**: Find B2B events to meet potential channel partners
- **Research & journalism**: Map the global conference landscape by industry or region

### How to scrape 10times.com events

1. Go to the [10times Trade Shows & Events Scraper](https://apify.com/automation-lab/10times-events-scraper) page on Apify Store.
2. Provide one or more **Start URLs** (10times.com city/category pages in `/city-country/industry` format), OR enter a **Search query**.
3. Set **Max results** (default 15).
4. Keep **Proxy configuration** set to Residential (required to bypass Cloudflare).
5. Click **Start** and download your data as JSON, CSV, or Excel.

### Input parameters

| Parameter | Type | Description |
|-----------|------|-------------|
| `startUrls` | Array | List of 10times.com category pages to scrape. Use format: `/city-country/industry` (e.g. `https://10times.com/london-uk/technology`) |
| `searchQuery` | String | Keyword to search on 10times.com. Example: `blockchain summit`, `pharma trade show` (requires residential proxies) |
| `maxResults` | Integer | Maximum number of events to extract, 1–1000 (default: 15) |
| `proxyConfiguration` | Object | Apify proxy settings. **Residential proxies required** — 10times.com is Cloudflare-protected |
| `maxRequestRetries` | Integer | Retry attempts for failed requests (default: 3) |

### Output example

```json
{
  "name": "London Tech Week",
  "url": "https://10times.com/london-technology-week",
  "startDate": "2026-06-08",
  "endDate": "2026-06-10",
  "city": "London",
  "state": null,
  "country": null,
  "venue": null,
  "edition": "13th edition",
  "attendees": 50000,
  "exhibitors": 300,
  "tags": ["Tradeshow", "IT & Technology"],
  "imageUrl": "https://img.10times.com/event/ltw-logo.jpg",
  "description": "London Tech Week is the world's largest technology festival, bringing together 50,000+ attendees from 90+ countries...",
  "sourceUrl": "https://10times.com/london-uk/technology",
  "scrapedAt": "2026-05-10T08:00:00.000Z"
}
````

### Supported URL formats

The actor works with 10times.com location/category listing pages:

- **Location+category pages (recommended)**: `https://10times.com/london-uk/technology`, `https://10times.com/new-york-us/pharmaceutical`, `https://10times.com/berlin-de/automotive`
- **Search pages**: `https://10times.com/search?q=blockchain`, `https://10times.com/search?q=AI+summit` (requires residential proxies)
- **Country/industry pages**: `https://10times.com/usa/healthcare`, `https://10times.com/uk/finance`

### Proxy requirements

10times.com is protected by Cloudflare and blocks datacenter IP ranges. **Residential proxies are required** for reliable access. The actor defaults to Apify's residential proxy group (`RESIDENTIAL`). Using the actor without residential proxies will result in Cloudflare blocks and empty output.

### Cost & pricing

This actor uses **pay-per-event** pricing:

| Tier | Start fee | Per event |
|------|-----------|-----------|
| FREE | $0.03 | $0.004506 |
| BRONZE | $0.03 | $0.003918 |
| SILVER | $0.03 | $0.003056 |
| GOLD | $0.03 | $0.002351 |
| PLATINUM | $0.03 | $0.001567 |
| DIAMOND | $0.03 | $0.001097 |

The start fee covers Playwright browser startup + Cloudflare bypass overhead (required for 10times.com). A FREE-tier run extracting 100 events costs approximately **$0.481** ($0.03 start + 100 × $0.004506).

### API usage

Use the [Apify API](https://docs.apify.com/api/v2) to integrate this actor into your workflows.

#### JavaScript (ApifyClient)

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/10times-events-scraper').call({
    startUrls: [{ url: 'https://10times.com/london-uk/technology' }],
    maxResults: 50,
    proxyConfiguration: { useApifyProxy: true, apifyProxyGroups: ['RESIDENTIAL'] },
});

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

#### Python (ApifyClient)

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('automation-lab/10times-events-scraper').call(run_input={
    'startUrls': [{'url': 'https://10times.com/london-uk/technology'}],
    'maxResults': 50,
    'proxyConfiguration': {'useApifyProxy': True, 'apifyProxyGroups': ['RESIDENTIAL']},
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(f'Events: {len(items)}')
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~10times-events-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://10times.com/london-uk/technology"}],
    "maxResults": 50,
    "proxyConfiguration": {"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}
  }'
```

### MCP / AI assistant usage

This actor is accessible via the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). Claude, GPT, and other AI assistants can call it directly when configured with the Apify MCP integration.

#### Setup with Claude Desktop / Claude Code

Add this specific actor to Claude via the Apify MCP server (HTTP transport):

```bash
claude mcp add --transport http https://mcp.apify.com?tools=automation-lab/10times-events-scraper
```

Or configure it in **Claude Desktop** (`claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "apify-10times": {
      "command": "npx",
      "args": ["-y", "@apify/mcp-server@latest", "--tools=automation-lab/10times-events-scraper"],
      "env": {
        "APIFY_TOKEN": "your-apify-token"
      }
    }
  }
}
```

For **VS Code / Cursor**, add to your MCP settings JSON:

```json
{
  "mcp": {
    "servers": {
      "apify-10times": {
        "url": "https://mcp.apify.com?tools=automation-lab/10times-events-scraper",
        "headers": { "Authorization": "Bearer your-apify-token" }
      }
    }
  }
}
```

#### Example prompts

You can ask your AI assistant:

- *"Use the 10times Trade Shows & Events Scraper to find upcoming pharmaceutical trade shows in New York"*
- *"Find all technology conferences in London next quarter using 10times scraper"*
- *"Get me a list of automotive trade shows in Germany using 10times.com"*

### Limitations

- Detailed event pages (description, full organizer contacts, speaker lists) are not scraped — listing-level data only
- Some events may show limited metadata if 10times.com does not display those fields on the listing page
- The actor requires residential proxies to bypass Cloudflare protection

### FAQ

**Q: Why am I getting empty results?**\
A: Ensure you have residential proxies configured. 10times.com blocks datacenter IPs via Cloudflare. Go to the Proxy configuration input and enable Apify Residential proxy.

**Q: What URL format does 10times.com use for category pages?**\
A: Use the format `/city-country/industry`, e.g. `https://10times.com/london-uk/technology`, `https://10times.com/new-york-us/pharmaceutical`. You can find these URLs by browsing 10times.com and copying the URL from the address bar on a category listing page.

**Q: Can I scrape all upcoming events globally?**\
A: Yes. Use multiple start URLs covering different cities and industries, or use the search feature with `searchQuery: "upcoming events"`.

**Q: How much does it cost to scrape 1,000 events?**\
A: At FREE tier: $0.03 (start) + 1000 × $0.004506 = ~$4.536.

### Integrations

Connect this actor to your existing tools and automate event intelligence workflows:

- **→ Google Sheets** via [Apify → Google Sheets integration](https://apify.com/apify/google-sheets-import-export): automatically populate a live spreadsheet with trade show data for ongoing event monitoring and team collaboration
- **→ Make / Zapier webhook**: trigger a workflow whenever new events are scraped — send Slack alerts, create CRM records, or add events to a project management tool
- **→ CRM import (Salesforce, HubSpot)**: pipe the JSON output directly into your CRM for sales prospecting — filter by `tags` (e.g. `Tradeshow`, `IT & Technology`) and `city` to build targeted outreach lists
- **→ Apify Storage → Snowflake / BigQuery**: schedule regular runs and export datasets to your data warehouse for trend analysis across quarters
- **→ Notion / Airtable**: use the Apify webhook or Zapier to push each scraped event as a new database record — ideal for event marketing teams tracking sponsorship and speaking opportunities

### Related actors

- [Eventbrite Scraper](https://apify.com/automation-lab/eventbrite-scraper) — scrapes events from Eventbrite
- [LinkedIn Company Scraper](https://apify.com/automation-lab/linkedin-company-scraper) — extract company data from LinkedIn

### Legality

This actor is intended for legitimate research, sales intelligence, and market analysis use cases. Users are responsible for complying with [10times.com's Terms of Service](https://10times.com/terms-of-service) and applicable laws regarding data collection and use. Do not use extracted data for spam or unsolicited outreach. Scraping publicly available event listings is generally permitted for research and commercial intelligence purposes; consult legal counsel if in doubt about your specific use case.

# Actor input Schema

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

List of 10times.com category pages to scrape (e.g. https://10times.com/london-uk/technology or https://10times.com/new-york-us/pharmaceutical). Use format: /city-country/industry. Residential proxies required.

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

Keyword to search events on 10times.com (e.g. 'blockchain', 'healthcare trade show', 'AI summit'). Used when no startUrls are provided, or combined with startUrls.

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

Maximum number of events to extract. Each event costs $0.003 (FREE tier).

## `proxyConfiguration` (type: `object`):

Apify proxy settings. Residential proxies are strongly recommended — 10times.com blocks datacenter IPs via Cloudflare.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts per failed request.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://10times.com/london-uk/technology"
    }
  ],
  "searchQuery": "tech conferences",
  "maxResults": 15,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxRequestRetries": 3
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://10times.com/london-uk/technology"
        }
    ],
    "searchQuery": "tech conferences",
    "maxResults": 15,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    },
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/10times-events-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 = {
    "startUrls": [{ "url": "https://10times.com/london-uk/technology" }],
    "searchQuery": "tech conferences",
    "maxResults": 15,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/10times-events-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 '{
  "startUrls": [
    {
      "url": "https://10times.com/london-uk/technology"
    }
  ],
  "searchQuery": "tech conferences",
  "maxResults": 15,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxRequestRetries": 3
}' |
apify call automation-lab/10times-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "10times Trade Shows & Events Scraper",
        "description": "Scrapes B2B trade shows, conferences, and events from 10times.com including event details, dates, venues, and organizer information",
        "version": "0.1",
        "x-build-id": "aeLts3FdPxdznKSXP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~10times-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-10times-events-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~10times-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-10times-events-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~10times-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-10times-events-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of 10times.com category pages to scrape (e.g. https://10times.com/london-uk/technology or https://10times.com/new-york-us/pharmaceutical). Use format: /city-country/industry. Residential proxies required.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword to search events on 10times.com (e.g. 'blockchain', 'healthcare trade show', 'AI summit'). Used when no startUrls are provided, or combined with startUrls."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of events to extract. Each event costs $0.003 (FREE tier).",
                        "default": 15
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Residential proxies are strongly recommended — 10times.com blocks datacenter IPs via Cloudflare."
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts per failed request.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
