# Swapcard Event Scraper — Exhibitors, Speakers & Contacts (`scrapesage/swapcard-exhibitor-scraper`) Actor

Scrape any public Swapcard event into structured data: every exhibitor with real company description, email, website, full address, product categories and booth, plus all speakers and sessions. Optional speaker enrichment adds bios, socials, job titles and custom fields.

- **URL**: https://apify.com/scrapesage/swapcard-exhibitor-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Lead generation, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 exhibitor scrapeds

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

## Swapcard Event Scraper — Exhibitors, Speakers & Contacts

Extract every public **exhibitor** and **speaker** from any [Swapcard](https://www.swapcard.com/) event — straight from Swapcard's own GraphQL API. No browser, no rendering overhead: a full ~1,300-record event scrapes in **under 4 minutes**, structured and deduplicated.

Built for **lead generation, market research, and event intelligence** — turn a public event into a clean exhibitor database with company emails, websites, addresses, and product categories, plus the full speaker lineup.

---

### What you get

#### Per exhibitor — full company profile (default)
| Field | Notes |
|---|---|
| Name, type, featured flag, booth(s) | |
| **Company description** | The real profile copy, not the floor-plan placeholder |
| **Email**, **website** | |
| **Social links** | LinkedIn, X, Facebook, Instagram, YouTube |
| **Full split address** | line 1, line 2, city, state, postal code, country |
| **Product categories** & track | |
| Phone numbers, documents, logo | |
| `customFields` | Every custom field the event defines — nothing dropped |
| **Booth contact persons** | Name, title, organization, photo — **included free** when listed |

#### Per speaker — agenda lineup (default)
Name, organization, photo, profile URL, and the session title(s) they present.

#### Per speaker — full profile enrichment (optional, paid add-on)
Enable `includeSpeakerDetails` to add, per speaker:
- **Biography**, **job title**, **website**
- **Social links** (LinkedIn / X / Instagram / Facebook / YouTube)
- **All custom profile fields** — job level, member type, country, time zone, and whatever else the event defines
- **Detailed sessions** — start/end times, room, and format
- A booth cross-reference when the speaker is also exhibitor staff

> **Privacy:** personal contact details (personal email, phone, home address) are **never collected**. Public professional data only.

---

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | — | **Required.** Public Swapcard event URLs, e.g. `https://app.swapcard.com/event/<slug>/exhibitors/<viewId>`. Subdomain and `/widget/` variants are supported. |
| `includeDetails` | boolean | `true` | Full exhibitor enrichment (description, email, address, categories, socials…). |
| `includeContacts` | boolean | `true` | Booth contact persons (name / title / org / photo) — free, part of the exhibitor record. |
| `includeSpeakers` | boolean | `true` | Scrape the speaker / agenda views (fast base fields). |
| `includeSpeakerDetails` | boolean | `false` | **Paid add-on.** Full speaker profiles (bio, socials, job title, website, custom fields, detailed sessions). Adds time; billed only per speaker actually enriched. |
| `maxItems` | integer | `3000` | Record cap (exhibitors + speakers share it). |
| `proxyConfiguration` | object | Datacenter | Apify Proxy. Rotates IPs per request; auto-escalates to residential only if a tier starts failing. |
| `minRequestDelayMs` | integer | `250` | Politeness delay before each request (plus jitter). |
| `maxConcurrency` | integer | `20` | Parallelism for detail fetches (1–30). |

Minimal input (this exact input runs — it's a public demo event):

```json
{
  "startUrls": [
    { "url": "https://app.swapcard.com/event/evolve-the-virtual-event-for-planners/exhibitors/RXZlbnRWaWV3XzMwNTk4" }
  ]
}
````

#### How to get your event URL

The input is the **exhibitor-list view** URL — not the event's marketing page and not a single company's profile. To get it:

1. Open the event in the Swapcard web app (`app.swapcard.com/event/...`).
2. Click the **Exhibitors** (sometimes **Partners & Exhibitors**) tab so the full list is on screen.
3. Copy the URL from your browser's address bar. It looks like:
   `https://app.swapcard.com/event/<event-slug>/exhibitors/<viewId>`

That `/exhibitors/<viewId>` path (plural, with a view ID) is what the Actor needs. A single company page (`/exhibitor/<id>`, singular) or the public `swapcard.com` marketing site are **not** valid inputs. Speaker/agenda views on the same event are picked up automatically — you only need the one exhibitor-list URL.

**Working example** (a public event you can open right now to see the format):
[`https://app.swapcard.com/event/evolve-the-virtual-event-for-planners/exhibitors/RXZlbnRWaWV3XzMwNTk4`](https://app.swapcard.com/event/evolve-the-virtual-event-for-planners/exhibitors/RXZlbnRWaWV3XzMwNTk4)

***

### Output

Every record is pushed to the dataset with a **stable schema** — the same keys on every row, missing values as explicit `null`, so it drops cleanly into a CRM, spreadsheet, or pipeline. Each record carries a `recordType` of `exhibitor` or `speaker`.

In the dataset, switch to the **Exhibitors** or **Speakers** view for a clean per-type table, or **All fields** for everything.

Example exhibitor record (abbreviated):

```json
{
  "recordType": "exhibitor",
  "exhibitorName": "Acme Analytics",
  "exhibitorType": "Featured Exhibitor",
  "boothNumber": "1224",
  "description": "Acme builds lab-grade analytics instruments…",
  "email": "sales@acme.example",
  "website": "https://acme.example",
  "socialLinks": { "linkedin": "https://www.linkedin.com/company/acme" },
  "city": "Raleigh", "state": "NC", "country": "United States",
  "categories": ["Instrumentation", "Data & AI"],
  "track": "Instrumentation & Nanoscience",
  "contactPersons": [
    { "name": "Jane Doe", "jobTitle": "Sales Director", "organization": "Acme Analytics" }
  ],
  "profileUrl": "https://app.swapcard.com/event/.../exhibitor/...",
  "eventName": "Your Event",
  "scrapedAt": "2026-06-02T00:00:00.000Z"
}
```

***

### Pricing — pay per result

| Event | When it's charged |
|---|---|
| **`exhibitor-scraped`** | Per exhibitor returned. Includes the full profile **and booth contacts** at no extra charge. |
| **`speaker-detail`** | Per speaker **actually enriched** (only with `includeSpeakerDetails` on). Speakers that return no extra data cost nothing — **you pay only for results that worked.** |

Platform usage (compute and proxies) is **included free** — you pay only the per-result prices above, capped by the max cost per run you set. No surprise compute bills.

***

### How it works

This Actor talks to Swapcard's GraphQL API directly — the same API the Swapcard web app uses — rather than rendering pages in a browser. That's why it's fast and cheap, and why the output is already structured rather than parsed out of HTML.

- **Resilient by design.** If Swapcard rotates an API hash, the core exhibitor scrape keeps working and any affected add-on surfaces a clear warning instead of failing the run.
- **Complete by default.** Pagination is followed to the end, and the run validates exhibitor coverage against the event's reported total — it warns loudly rather than silently shipping a partial dataset.
- **Honest run status.** If an event has no public exhibitors or speakers (e.g. a finished event), the run **succeeds** with a plain-English explanation and charges nothing — it never reports a false error.

***

### Common uses

- **Lead generation** — exhibitor companies with emails, websites, and booth contacts.
- **Competitive & market research** — who exhibits in a category, with product tags and tracks.
- **Event & sponsorship intelligence** — full exhibitor and speaker lineups, enriched on demand.

***

### Support & requests

Found a bug, need an extra field, or want a different field exposed? Open an issue on the **Issues** tab — it's monitored and fixes ship fast.

# Actor input Schema

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

Public Swapcard event / exhibitor-list URLs, e.g. https://app.swapcard.com/event/<slug>/exhibitors/<viewId> (subdomain and /widget/ variants are also supported). Non-Swapcard URLs are skipped with a warning.

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

Enrich every exhibitor with its full public profile: real company description, email, website, social links, full split address (line1/line2/city/state/postal/country), product categories, track, phone numbers, booths and documents. ON by default — it's fast on datacenter and gives the most complete dataset. Turn off for a faster, name/booth-only pass.

## `includeContacts` (type: `boolean`):

Include each exhibitor's booth team / contact persons (name, job title, organization, photo) — included free as part of the exhibitor record. Personal contact details (email, phone) are never collected. Many events list no booth team, in which case this is simply empty. Turn off if you don't want per-person rows on exhibitors.

## `includeSpeakers` (type: `boolean`):

Also scrape the public speaker/agenda (Planning) views if present — speaker name, organization, photo, profile URL, and the session title(s) they appear on. Fast.

## `includeSpeakerDetails` (type: `boolean`):

Adds each speaker's full public profile: biography, social links (LinkedIn/X/Instagram/Facebook/YouTube), job title, website, all custom profile fields (job level, country, etc.), and detailed sessions with times and rooms. This makes runs slower (one profile call per speaker). BILLING: you are charged ONLY for each speaker that actually returns extra data — speakers with no profile data added cost nothing. Personal contact details (email, phone, home address) are never collected.

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

Hard cap on the number of records (a safety limit). Exhibitors and speakers share this budget. The default is generous so a full event isn't truncated for typical events — your real spend guard is the max cost per run you set in the monetization settings. Lower this only if you want a hard record cap.

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

Apify Proxy. Default is DATACENTER, which is fast, cheap and (verified) returns clean data on Swapcard's GraphQL. The actor draws a fresh IP per request and automatically escalates to residential on repeated failures, so a transient block self-heals. Pick residential here only if a specific event proves to need it.

## `minRequestDelayMs` (type: `integer`):

Politeness delay before each GraphQL request; a random jitter of up to the same amount is added on top. Kept low because datacenter is fast and requests rotate IPs.

## `maxConcurrency` (type: `integer`):

Parallelism for per-exhibitor and per-session detail fetches (and across start URLs). Higher is faster; the IP rotation and retry/backoff keep it safe.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://app.swapcard.com/event/evolve-the-virtual-event-for-planners/exhibitors/RXZlbnRWaWV3XzMwNTk4"
    }
  ],
  "includeDetails": true,
  "includeContacts": true,
  "includeSpeakers": true,
  "includeSpeakerDetails": false,
  "maxItems": 3000,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "minRequestDelayMs": 250,
  "maxConcurrency": 20
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `exhibitors` (type: `string`):

No description

## `speakers` (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://app.swapcard.com/event/evolve-the-virtual-event-for-planners/exhibitors/RXZlbnRWaWV3XzMwNTk4"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/swapcard-exhibitor-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://app.swapcard.com/event/evolve-the-virtual-event-for-planners/exhibitors/RXZlbnRWaWV3XzMwNTk4" }],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/swapcard-exhibitor-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://app.swapcard.com/event/evolve-the-virtual-event-for-planners/exhibitors/RXZlbnRWaWV3XzMwNTk4"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapesage/swapcard-exhibitor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Swapcard Event Scraper — Exhibitors, Speakers & Contacts",
        "description": "Scrape any public Swapcard event into structured data: every exhibitor with real company description, email, website, full address, product categories and booth, plus all speakers and sessions. Optional speaker enrichment adds bios, socials, job titles and custom fields.",
        "version": "0.11",
        "x-build-id": "7KZYKYfGffxdbeEuq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~swapcard-exhibitor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-swapcard-exhibitor-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/scrapesage~swapcard-exhibitor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-swapcard-exhibitor-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/scrapesage~swapcard-exhibitor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-swapcard-exhibitor-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Swapcard event URLs",
                        "type": "array",
                        "description": "Public Swapcard event / exhibitor-list URLs, e.g. https://app.swapcard.com/event/<slug>/exhibitors/<viewId> (subdomain and /widget/ variants are also supported). Non-Swapcard URLs are skipped with a warning.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "includeDetails": {
                        "title": "Include full exhibitor details",
                        "type": "boolean",
                        "description": "Enrich every exhibitor with its full public profile: real company description, email, website, social links, full split address (line1/line2/city/state/postal/country), product categories, track, phone numbers, booths and documents. ON by default — it's fast on datacenter and gives the most complete dataset. Turn off for a faster, name/booth-only pass.",
                        "default": true
                    },
                    "includeContacts": {
                        "title": "Include booth contact persons",
                        "type": "boolean",
                        "description": "Include each exhibitor's booth team / contact persons (name, job title, organization, photo) — included free as part of the exhibitor record. Personal contact details (email, phone) are never collected. Many events list no booth team, in which case this is simply empty. Turn off if you don't want per-person rows on exhibitors.",
                        "default": true
                    },
                    "includeSpeakers": {
                        "title": "Include speakers",
                        "type": "boolean",
                        "description": "Also scrape the public speaker/agenda (Planning) views if present — speaker name, organization, photo, profile URL, and the session title(s) they appear on. Fast.",
                        "default": true
                    },
                    "includeSpeakerDetails": {
                        "title": "Enrich speakers with full profiles (paid add-on)",
                        "type": "boolean",
                        "description": "Adds each speaker's full public profile: biography, social links (LinkedIn/X/Instagram/Facebook/YouTube), job title, website, all custom profile fields (job level, country, etc.), and detailed sessions with times and rooms. This makes runs slower (one profile call per speaker). BILLING: you are charged ONLY for each speaker that actually returns extra data — speakers with no profile data added cost nothing. Personal contact details (email, phone, home address) are never collected.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the number of records (a safety limit). Exhibitors and speakers share this budget. The default is generous so a full event isn't truncated for typical events — your real spend guard is the max cost per run you set in the monetization settings. Lower this only if you want a hard record cap.",
                        "default": 3000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy. Default is DATACENTER, which is fast, cheap and (verified) returns clean data on Swapcard's GraphQL. The actor draws a fresh IP per request and automatically escalates to residential on repeated failures, so a transient block self-heals. Pick residential here only if a specific event proves to need it.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "minRequestDelayMs": {
                        "title": "Minimum request delay (ms)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Politeness delay before each GraphQL request; a random jitter of up to the same amount is added on top. Kept low because datacenter is fast and requests rotate IPs.",
                        "default": 250
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Parallelism for per-exhibitor and per-session detail fetches (and across start URLs). Higher is faster; the IP rotation and retry/backoff keep it safe.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
