# OpenSea + Magic Eden NFT Scraper (`crawlerbros/opensea-magiceden-nft`) Actor

Scrape NFT collections, listings, sales, activity feeds, and individual NFT metadata from OpenSea (Ethereum, Polygon, Base, etc.) and Magic Eden (Solana). Floor prices, volume, owners, traits, current listings, recent sales/bids, public API, no login required.

- **URL**: https://apify.com/crawlerbros/opensea-magiceden-nft.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 16 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## OpenSea + Magic Eden NFT Scraper

Scrape NFT collections, listings, sales, activity feeds, and individual NFT metadata from **OpenSea** (Ethereum, Polygon, Base, Arbitrum, Optimism, Avalanche, BSC, Blast, Zora, and more) and **Magic Eden** (Solana). Pick the platform, pick the mode, get clean structured JSON.

### What you can do with it

- Track floor prices and 24-hour volume across major NFT marketplaces.
- Monitor recent sales (fills) and bids on a collection.
- Get the current listings (asks) for a collection.
- Look up a single NFT by chain + contract + tokenId (OpenSea) or token mint (Magic Eden).
- Fetch the top trending Solana collections on Magic Eden in real time.
- Browse OpenSea's top collections by market cap, 7-day volume, or owner count.
- Paste any opensea.io or magiceden.io URL — the scraper auto-detects platform and entity.

### Modes

| Mode | OpenSea | Magic Eden | What it does |
|---|---|---|---|
| `byCollection` | yes | yes | Collection metadata (name, description, socials, contracts) |
| `collectionStats` | yes | yes | Floor price, volume, sales count, owners |
| `listingsByCollection` | needs API key | yes | Current asks (sellers willing to sell at price) |
| `salesByCollection` | needs API key | yes | Recent filled sales |
| `activitiesByCollection` | needs API key | yes | Sale + listing + bid feed (Magic Eden native) |
| `byNft` | needs API key | yes | Single NFT detail by chain+contract+tokenId or token mint |
| `searchCollections` | needs API key | yes | Browse top collections (sortable on OpenSea) |
| `popularCollections` | — | yes | Magic Eden trending collections (1h/1d/7d/30d) — default daily-test mode, no auth |
| `byUrl` | yes | yes | Paste a marketplace URL, get metadata back |

### Getting an OpenSea API key (recommended)

OpenSea's `byCollection` and `collectionStats` modes work without an API key. **All other OpenSea modes require a free key** (request blocks return HTTP 401 otherwise).

1. Sign in at https://opensea.io.
2. Go to https://docs.opensea.io/reference/api-keys and request a key (free, instant).
3. Paste the key into the **OpenSea API key** input field. The scraper sets `X-API-KEY` automatically.

Magic Eden does **not** require any auth — every Magic Eden mode runs out of the box.

### Output fields

#### Collection record (`recordType=collection`)

| Field | Notes |
|---|---|
| `platform` | `opensea` or `magiceden` |
| `slug` / `symbol` | OpenSea slug or Magic Eden symbol |
| `name` | Display name |
| `description` | Collection description |
| `imageUrl` / `image` | Logo |
| `bannerImageUrl` | Banner (OpenSea only) |
| `discordUrl` / `discord` | Discord invite |
| `twitterUsername` / `twitter` | X / Twitter handle |
| `projectUrl` / `website` | External site |
| `contracts` | Array `[{address, chain}]` (OpenSea) |
| `categories` | Tags (Magic Eden) |
| `hasCNFTs` | Compressed NFT support flag (Magic Eden) |
| `url` | Direct marketplace URL |

#### Stats record (`recordType=stats`)

OpenSea: `volumeAll`, `salesAll`, `numOwners`, `floorPrice`, `floorPriceSymbol`, `marketCap`, `intervals[]` (per-window aggregates).
Magic Eden: `floorPriceLamports`, `floorPriceSol`, `listedCount`, `avgPrice24hrSol`, `volumeAllSol`.

#### Listing / sale / activity / NFT records

Builders are documented in the dataset overview. Every record drops empty fields and passes a recursive null-walker before push.

Every record also carries `recordType` (`collection` / `stats` / `listing` / `event` / `activity` / `nft` / `error`), `platform` (`opensea` / `magiceden`), `siteName` (`OpenSea` / `Magic Eden`), and `scrapedAt` (ISO-8601 UTC) — parity with the rest of the Apify Store fleet.

### Defaults (daily-test prefill)

`platform=magiceden, mode=popularCollections, timeRange=1d, maxItems=10`

Magic Eden's popular-collections endpoint is fully public, so the daily test always returns 10 records without any user-supplied credentials.

### FAQs

**Do I need a proxy?** No. Both APIs respond cleanly from datacenter IPs. The actor auto-escalates to Apify proxy on 429 / 5xx.

**Why is OpenSea limited without an API key?** OpenSea moved most v2 endpoints behind X-API-KEY in late 2023. The free tier (~4 req/sec) is plenty for moderate use; we honor `Retry-After` on 429.

**Can I scrape Solana NFTs from OpenSea?** Set `chain=solana` and `platform=opensea`. OpenSea also indexes Solana now.

**Magic Eden EVM (Ethereum / Polygon)?** Magic Eden's EVM API surface (v3 RTP) is unstable from server-side IPs at the time of writing — set `platform=magiceden` with mode=byCollection only on Solana symbols. For EVM collections, use `platform=opensea`.

**Are NFT image URLs accessible?** OpenSea CDN images (`i.seadn.io`) and IPFS-hosted images (`ipfs.io`, `arweave.net`) are public; we ship original URLs and you can re-fetch them client-side. Some IPFS gateways are flaky — the URL is preserved as-is for traceability.

### Limitations

- OpenSea search is **not** full-text — it's a ranked list of top collections. The `searchQuery` field is informational only.
- Magic Eden EVM (v3 RTP) endpoints sometimes 404 from datacenter IPs and are not exposed in this version. Use Solana symbols only on Magic Eden.
- OpenSea events feed has a hard limit of 50 results per page; we paginate within `maxItems`.

### Pricing

You are billed per Apify Compute Unit. There is no per-record fee on this actor.

# Actor input Schema

## `platform` (type: `string`):

Which NFT marketplace to scrape.
## `mode` (type: `string`):

What to scrape. `popularCollections` (Magic Eden only) needs no auth and is the recommended default.
## `collectionSlugs` (type: `array`):

OpenSea collection slugs (e.g. `azuki`, `boredapeyachtclub`) or Magic Eden collection symbols (e.g. `okay_bears`, `degenerate_ape_academy`). For `byCollection`, the underlying API serves slug-keyed metadata.
## `chain` (type: `string`):

Blockchain network for OpenSea NFT lookup. Magic Eden uses Solana (no chain param needed).
## `contractAddress` (type: `string`):

Smart-contract address holding the NFT (e.g. `0xed5af388653567af2f388e6224dc7c4b3241c544` for Azuki).
## `tokenId` (type: `string`):

Token ID inside the contract (numeric string, e.g. `9605`).
## `tokenMint` (type: `string`):

Solana token mint address for the NFT.
## `searchQuery` (type: `string`):

Optional free-text label. Both upstreams return ranked collection lists rather than full-text search; this field is logged but not sent to the API.
## `sortBy` (type: `string`):

Sort key for OpenSea collections list. Magic Eden popular feed uses `timeRange` instead.
## `timeRange` (type: `string`):

Window for Magic Eden popular-collections ranking.
## `eventType` (type: `string`):

Filter activity feed to a single event type.
## `urls` (type: `array`):

Paste opensea.io collection / item URLs or magiceden.io collection / item URLs. The actor auto-detects platform and entity type.
## `openseaApiKey` (type: `string`):

Free API key from https://docs.opensea.io/reference/api-keys. Without one, only `byCollection` and `collectionStats` modes work on OpenSea (other modes return 401). Magic Eden does NOT need a key.
## `maxItems` (type: `integer`):

Hard cap on emitted records across all modes.
## `autoEscalateOnBlock` (type: `boolean`):

If true (default), the actor engages Apify proxy on HTTP 429 / 5xx anti-bot blocks. Both APIs work cleanly from datacenter IPs in normal conditions.
## `proxyGroups` (type: `array`):

Apify proxy groups to engage on auto-escalation. Empty = datacenter (default), then residential fallback.

## Actor input object example

```json
{
  "platform": "magiceden",
  "mode": "popularCollections",
  "collectionSlugs": [
    "azuki"
  ],
  "chain": "ethereum",
  "sortBy": "market_cap",
  "timeRange": "1d",
  "eventType": "sale",
  "urls": [
    "https://magiceden.io/marketplace/okay_bears",
    "https://opensea.io/collection/azuki"
  ],
  "maxItems": 10,
  "autoEscalateOnBlock": true,
  "proxyGroups": []
}
````

# Actor output Schema

## `records` (type: `string`):

Dataset of all scraped NFT records.

# 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 = {
    "platform": "magiceden",
    "mode": "popularCollections",
    "chain": "ethereum",
    "sortBy": "market_cap",
    "timeRange": "1d",
    "eventType": "sale",
    "maxItems": 10,
    "autoEscalateOnBlock": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/opensea-magiceden-nft").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 = {
    "platform": "magiceden",
    "mode": "popularCollections",
    "chain": "ethereum",
    "sortBy": "market_cap",
    "timeRange": "1d",
    "eventType": "sale",
    "maxItems": 10,
    "autoEscalateOnBlock": True,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/opensea-magiceden-nft").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 '{
  "platform": "magiceden",
  "mode": "popularCollections",
  "chain": "ethereum",
  "sortBy": "market_cap",
  "timeRange": "1d",
  "eventType": "sale",
  "maxItems": 10,
  "autoEscalateOnBlock": true
}' |
apify call crawlerbros/opensea-magiceden-nft --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/opensea-magiceden-nft",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenSea + Magic Eden NFT Scraper",
        "description": "Scrape NFT collections, listings, sales, activity feeds, and individual NFT metadata from OpenSea (Ethereum, Polygon, Base, etc.) and Magic Eden (Solana). Floor prices, volume, owners, traits, current listings, recent sales/bids, public API, no login required.",
        "version": "1.0",
        "x-build-id": "G0I1OmInXARBVvCnT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~opensea-magiceden-nft/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-opensea-magiceden-nft",
                "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/crawlerbros~opensea-magiceden-nft/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-opensea-magiceden-nft",
                "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/crawlerbros~opensea-magiceden-nft/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-opensea-magiceden-nft",
                "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": [
                    "platform",
                    "mode"
                ],
                "properties": {
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "opensea",
                            "magiceden"
                        ],
                        "type": "string",
                        "description": "Which NFT marketplace to scrape.",
                        "default": "magiceden"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "byCollection",
                            "collectionStats",
                            "listingsByCollection",
                            "salesByCollection",
                            "activitiesByCollection",
                            "byNft",
                            "searchCollections",
                            "popularCollections",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to scrape. `popularCollections` (Magic Eden only) needs no auth and is the recommended default.",
                        "default": "popularCollections"
                    },
                    "collectionSlugs": {
                        "title": "Collection slugs / symbols (mode=byCollection, collectionStats, listingsByCollection, salesByCollection, activitiesByCollection)",
                        "type": "array",
                        "description": "OpenSea collection slugs (e.g. `azuki`, `boredapeyachtclub`) or Magic Eden collection symbols (e.g. `okay_bears`, `degenerate_ape_academy`). For `byCollection`, the underlying API serves slug-keyed metadata.",
                        "default": [
                            "azuki"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "chain": {
                        "title": "Chain (mode=byNft on OpenSea)",
                        "enum": [
                            "ethereum",
                            "matic",
                            "base",
                            "arbitrum",
                            "arbitrum_nova",
                            "optimism",
                            "avalanche",
                            "klaytn",
                            "bsc",
                            "zora",
                            "blast",
                            "sei",
                            "solana"
                        ],
                        "type": "string",
                        "description": "Blockchain network for OpenSea NFT lookup. Magic Eden uses Solana (no chain param needed).",
                        "default": "ethereum"
                    },
                    "contractAddress": {
                        "title": "Contract address (mode=byNft, OpenSea)",
                        "type": "string",
                        "description": "Smart-contract address holding the NFT (e.g. `0xed5af388653567af2f388e6224dc7c4b3241c544` for Azuki)."
                    },
                    "tokenId": {
                        "title": "Token ID (mode=byNft, OpenSea)",
                        "type": "string",
                        "description": "Token ID inside the contract (numeric string, e.g. `9605`)."
                    },
                    "tokenMint": {
                        "title": "Token mint (mode=byNft, Magic Eden / Solana)",
                        "type": "string",
                        "description": "Solana token mint address for the NFT."
                    },
                    "searchQuery": {
                        "title": "Search query (mode=searchCollections — informational; APIs return top collections regardless)",
                        "type": "string",
                        "description": "Optional free-text label. Both upstreams return ranked collection lists rather than full-text search; this field is logged but not sent to the API."
                    },
                    "sortBy": {
                        "title": "Sort order (mode=searchCollections, OpenSea)",
                        "enum": [
                            "market_cap",
                            "seven_day_volume",
                            "one_day_volume",
                            "num_owners",
                            "created_date"
                        ],
                        "type": "string",
                        "description": "Sort key for OpenSea collections list. Magic Eden popular feed uses `timeRange` instead.",
                        "default": "market_cap"
                    },
                    "timeRange": {
                        "title": "Time range (mode=popularCollections, Magic Eden)",
                        "enum": [
                            "1h",
                            "1d",
                            "7d",
                            "30d"
                        ],
                        "type": "string",
                        "description": "Window for Magic Eden popular-collections ranking.",
                        "default": "1d"
                    },
                    "eventType": {
                        "title": "Event type (mode=activitiesByCollection — Magic Eden / mode=salesByCollection — OpenSea)",
                        "enum": [
                            "sale",
                            "listing",
                            "delisting",
                            "bid",
                            "cancelBid",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter activity feed to a single event type.",
                        "default": "sale"
                    },
                    "urls": {
                        "title": "URLs (mode=byUrl)",
                        "type": "array",
                        "description": "Paste opensea.io collection / item URLs or magiceden.io collection / item URLs. The actor auto-detects platform and entity type.",
                        "default": [
                            "https://magiceden.io/marketplace/okay_bears",
                            "https://opensea.io/collection/azuki"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "openseaApiKey": {
                        "title": "OpenSea API key (optional but recommended)",
                        "type": "string",
                        "description": "Free API key from https://docs.opensea.io/reference/api-keys. Without one, only `byCollection` and `collectionStats` modes work on OpenSea (other modes return 401). Magic Eden does NOT need a key."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on emitted records across all modes.",
                        "default": 50
                    },
                    "autoEscalateOnBlock": {
                        "title": "Auto-escalate to Apify proxy on block",
                        "type": "boolean",
                        "description": "If true (default), the actor engages Apify proxy on HTTP 429 / 5xx anti-bot blocks. Both APIs work cleanly from datacenter IPs in normal conditions.",
                        "default": true
                    },
                    "proxyGroups": {
                        "title": "Apify proxy groups (used on auto-escalation)",
                        "type": "array",
                        "description": "Apify proxy groups to engage on auto-escalation. Empty = datacenter (default), then residential fallback.",
                        "default": [],
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
