# Crossref Scraper (`crawlerbros/crossref-scraper`) Actor

Scrape Crossref, the world's largest DOI registry. Search 130M+ scholarly works, fetch by DOI, filter by date / type / journal, and pull authors, references, citation counts, ISSN, ORCIDs, and more.

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

## Pricing

from $1.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

## Crossref Scraper

Scrape Crossref — the world's largest DOI registry. Search 130M+ scholarly works, fetch by DOI, filter by date / type / publisher. Pulls authors, references, citation counts, ISSN, ORCIDs, full bibliographic metadata. HTTP-only via the public `api.crossref.org` REST API. No auth, no proxy. Polite-pool email gives ~50 req/s rate limit.

### What this actor does

- **Four modes:** `searchWorks`, `byDois`, `byMember` (publisher), `byJournalIssn`
- **Universal IDs:** accepts bare DOIs, DOI URLs, `doi:` prefix
- **Filters:** publication date range, work type, member (publisher) ID, min citation count
- **Sorts:** relevance, published, citation count, deposit / index / issued date
- **Cursor pagination** — no 10k result cap (unlike most search APIs)
- **Optional references** — full cited references list per work
- **Empty fields are omitted** — no nulls in output

### Output per work

- `doi`, `doiUrl`, `title`, `subtitle`, `type`
- `publisher`, `containerTitle` (journal/book), `shortContainerTitle`
- `issn[]`, `isbn[]`
- `publishedDate`, `publishedYear`, `publishedPrintDate`, `publishedOnlineDate`
- `createdAt`, `depositedAt`, `indexedAt` — Crossref-internal lifecycle dates
- `isReferencedByCount` — how many works cite this one (Crossref's count)
- `referencesCount` — number of references in this work
- `authors[]` — `[{name, family, given, orcid, sequence, affiliations}, ...]`
- `primaryAuthor` — first author scalar
- `editors[]` (when present)
- `subjects[]` — Crossref's subject taxonomy
- `abstract` (when provided by publisher; usually JATS XML)
- `url`, `primaryUrl` — landing-page URLs
- `page`, `volume`, `issue`, `language`
- `licenses[]` — `[{url, contentVersion, delayInDays}, ...]`
- `references[]` — when `includeReferences=true`
- `score` — search relevance (search modes)
- `recordType: "work"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `searchWorks` | `searchWorks` / `byDois` / `byMember` / `byJournalIssn` |
| `searchQuery` | string | `large language models` | Free-text search |
| `queryAuthor` | string | – | Constrain to author |
| `queryTitle` | string | – | Constrain to title |
| `dois` | array | – | DOIs (mode=byDois) |
| `memberId` | string | – | Numeric Crossref member ID (mode=byMember) |
| `journalIssn` | string | – | Journal ISSN like `1532-4435` (mode=byJournalIssn) |
| `fromPubDate` | string | – | YYYY-MM-DD |
| `untilPubDate` | string | – | YYYY-MM-DD |
| `workType` | string | `any` | `journal-article`/`book`/`preprint`/etc. |
| `minCitationCount` | int | – | Drop works cited fewer times than this |
| `sortBy` | string | `relevance` | `relevance`/`published`/`is-referenced-by-count`/etc. |
| `sortOrder` | string | `desc` | `asc` / `desc` |
| `includeReferences` | bool | `false` | Include cited references |
| `userAgentEmail` | string | `apify-actor@noreply.apify.com` | Crossref polite-pool email |
| `maxItems` | int | `50` | Hard cap (1–10000) |

#### Example: top-cited LLM works since 2024

```json
{
  "mode": "searchWorks",
  "searchQuery": "large language models",
  "fromPubDate": "2024-01-01",
  "minCitationCount": 50,
  "sortBy": "is-referenced-by-count",
  "maxItems": 100
}
````

#### Example: lookup by DOI list

```json
{
  "mode": "byDois",
  "dois": [
    "10.1145/3442188.3445922",
    "https://doi.org/10.48550/arxiv.2310.06825",
    "doi:10.1126/science.abc1234"
  ],
  "includeReferences": true
}
```

#### Example: all journal articles by Springer (member 297) in 2024

```json
{
  "mode": "byMember",
  "memberId": "297",
  "workType": "journal-article",
  "fromPubDate": "2024-01-01",
  "untilPubDate": "2024-12-31",
  "maxItems": 500
}
```

#### Example: only datasets in your area

```json
{
  "mode": "searchWorks",
  "searchQuery": "climate temperature anomaly",
  "workType": "dataset",
  "sortBy": "published",
  "maxItems": 200
}
```

### Use cases

- **Citation enrichment** — feed any DOI list and get back citation counts, references, journal info
- **Literature reviews** — bulk-export every work matching a query, filter by date / type / publisher
- **Publisher monitoring** — track all output of a specific Crossref member ID
- **Reference resolution** — `includeReferences: true` resolves the bibliography of any reviewed paper
- **Bibliometrics** — author productivity, ORCID-based identification, citation networks

### FAQ

**What's Crossref?**  The not-for-profit registration agency for scholarly DOIs. ~130M registered works, sourced from 20k+ publishers (Springer, Elsevier, Wiley, ACM, Nature, etc.). See [crossref.org](https://www.crossref.org).

**Is there a rate limit?**  Crossref runs a polite pool (provide a contact email in User-Agent for higher limits — ~50 req/s). The actor sets this header automatically.

**How does it differ from OpenAlex?**  Crossref is the **registry**: every DOI's authoritative metadata. OpenAlex is the **derivative analytics layer**: citation counts (computed from references), concepts (computed via NLP), open-access detection (computed via Unpaywall). Use Crossref for canonical metadata, OpenAlex for citation networks + analytics.

**What ID formats are accepted?**  Bare DOIs (`10.1145/3442188.3445922`), full URLs (`https://doi.org/10.1145/3442188.3445922`), `doi:` prefix (`doi:10.1145/...`).

**What does `is-referenced-by-count` mean?**  How many *other Crossref-registered* works cite this one (i.e. citations from works whose own references are deposited at Crossref). It's a lower bound on real citation count.

**Why are abstracts often missing?**  Most publishers don't deposit abstracts at Crossref. When present, they're usually JATS-XML. For richer abstract coverage, query OpenAlex (the actor in this repo).

**What's a "member"?**  A Crossref publisher account. Each publisher has a numeric member ID; you can fetch all their works via `mode=byMember`. Find IDs at [api.crossref.org/members](https://api.crossref.org/members).

**Are references resolved to other works?**  Crossref returns references as nested objects with DOI / unstructured strings. To resolve them, run a `byDois` mode pass over the DOIs in the references array.

**What's the cursor pagination limit?**  Effectively unlimited (Crossref doesn't impose the 10k cap that most search APIs use). The actor walks cursors until it hits `maxItems` or runs out of results.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

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

Free-text query (mode=searchWorks).

## `queryAuthor` (type: `string`):

Constrain results to a specific author.

## `queryTitle` (type: `string`):

Constrain results to titles containing this phrase.

## `dois` (type: `array`):

Crossref DOIs to fetch directly. Accepts bare (`10.1145/...`) or full URL form.

## `memberId` (type: `string`):

Numeric Crossref member ID (a publisher). Example: `78` (Springer), `301` (IEEE), `7164` (Cambridge UP).

## `journalIssn` (type: `string`):

ISSN of a journal (e.g. `1532-4435` for JMLR, `0036-8075` for Science).

## `funderDoi` (type: `string`):

Crossref Funder Registry DOI. Examples: `10.13039/100000001` (NSF), `10.13039/100000002` (NIH), `10.13039/100000104` (NASA), `10.13039/501100000780` (European Commission). Lookup at https://search.crossref.org/funding.

## `fromPubDate` (type: `string`):

Drop works published before this date.

## `untilPubDate` (type: `string`):

Drop works published after this date.

## `workType` (type: `string`):

Crossref work type filter.

## `minCitationCount` (type: `integer`):

Drop works cited fewer times than this.

## `sortBy` (type: `string`):

Crossref sort order.

## `sortOrder` (type: `string`):

Ascending or descending order for the chosen sort field.

## `includeReferences` (type: `boolean`):

Include the cited references list (can be large for review articles).

## `userAgentEmail` (type: `string`):

Crossref's polite pool requires a contact email in User-Agent for higher rate limits.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "searchWorks",
  "searchQuery": "large language models",
  "dois": [],
  "workType": "any",
  "sortBy": "relevance",
  "sortOrder": "desc",
  "includeReferences": false,
  "userAgentEmail": "apify-actor@noreply.apify.com",
  "maxItems": 50
}
```

# Actor output Schema

## `works` (type: `string`):

Dataset containing all scraped Crossref works.

# 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 = {
    "mode": "searchWorks",
    "searchQuery": "large language models",
    "dois": [],
    "workType": "any",
    "sortBy": "relevance",
    "sortOrder": "desc",
    "includeReferences": false,
    "userAgentEmail": "apify-actor@noreply.apify.com",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/crossref-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 = {
    "mode": "searchWorks",
    "searchQuery": "large language models",
    "dois": [],
    "workType": "any",
    "sortBy": "relevance",
    "sortOrder": "desc",
    "includeReferences": False,
    "userAgentEmail": "apify-actor@noreply.apify.com",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/crossref-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 '{
  "mode": "searchWorks",
  "searchQuery": "large language models",
  "dois": [],
  "workType": "any",
  "sortBy": "relevance",
  "sortOrder": "desc",
  "includeReferences": false,
  "userAgentEmail": "apify-actor@noreply.apify.com",
  "maxItems": 50
}' |
apify call crawlerbros/crossref-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crossref Scraper",
        "description": "Scrape Crossref, the world's largest DOI registry. Search 130M+ scholarly works, fetch by DOI, filter by date / type / journal, and pull authors, references, citation counts, ISSN, ORCIDs, and more.",
        "version": "1.0",
        "x-build-id": "QM65LL5NapEDR1dHL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~crossref-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-crossref-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/crawlerbros~crossref-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-crossref-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/crawlerbros~crossref-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-crossref-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchWorks",
                            "byDois",
                            "byMember",
                            "byJournalIssn",
                            "byFunder"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "searchWorks"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text query (mode=searchWorks).",
                        "default": "large language models"
                    },
                    "queryAuthor": {
                        "title": "Query author",
                        "type": "string",
                        "description": "Constrain results to a specific author."
                    },
                    "queryTitle": {
                        "title": "Query title contains",
                        "type": "string",
                        "description": "Constrain results to titles containing this phrase."
                    },
                    "dois": {
                        "title": "DOIs (mode=byDois)",
                        "type": "array",
                        "description": "Crossref DOIs to fetch directly. Accepts bare (`10.1145/...`) or full URL form.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "memberId": {
                        "title": "Member ID (mode=byMember)",
                        "type": "string",
                        "description": "Numeric Crossref member ID (a publisher). Example: `78` (Springer), `301` (IEEE), `7164` (Cambridge UP)."
                    },
                    "journalIssn": {
                        "title": "Journal ISSN (mode=byJournalIssn)",
                        "type": "string",
                        "description": "ISSN of a journal (e.g. `1532-4435` for JMLR, `0036-8075` for Science)."
                    },
                    "funderDoi": {
                        "title": "Funder DOI (mode=byFunder)",
                        "type": "string",
                        "description": "Crossref Funder Registry DOI. Examples: `10.13039/100000001` (NSF), `10.13039/100000002` (NIH), `10.13039/100000104` (NASA), `10.13039/501100000780` (European Commission). Lookup at https://search.crossref.org/funding."
                    },
                    "fromPubDate": {
                        "title": "Published after (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Drop works published before this date."
                    },
                    "untilPubDate": {
                        "title": "Published before (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Drop works published after this date."
                    },
                    "workType": {
                        "title": "Work type",
                        "enum": [
                            "any",
                            "journal-article",
                            "book",
                            "book-chapter",
                            "proceedings-article",
                            "report",
                            "dataset",
                            "dissertation",
                            "preprint",
                            "posted-content",
                            "monograph",
                            "edited-book",
                            "reference-entry",
                            "standard"
                        ],
                        "type": "string",
                        "description": "Crossref work type filter.",
                        "default": "any"
                    },
                    "minCitationCount": {
                        "title": "Min citation count",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Drop works cited fewer times than this."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "published",
                            "is-referenced-by-count",
                            "deposited",
                            "indexed",
                            "issued"
                        ],
                        "type": "string",
                        "description": "Crossref sort order.",
                        "default": "relevance"
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "asc",
                            "desc"
                        ],
                        "type": "string",
                        "description": "Ascending or descending order for the chosen sort field.",
                        "default": "desc"
                    },
                    "includeReferences": {
                        "title": "Include references",
                        "type": "boolean",
                        "description": "Include the cited references list (can be large for review articles).",
                        "default": false
                    },
                    "userAgentEmail": {
                        "title": "User-Agent contact email",
                        "type": "string",
                        "description": "Crossref's polite pool requires a contact email in User-Agent for higher rate limits.",
                        "default": "apify-actor@noreply.apify.com"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
