# ©️ US Copyright Records Search (`nexgendata/us-copyright-records-search`) Actor

Search U.S. Copyright Office registrations and recordations (assignments/transfers) with titles, authors, claimants, work type, registration numbers and dates. For IP attorneys, music/film/publishing rights teams, and due-diligence.

- **URL**: https://apify.com/nexgendata/us-copyright-records-search.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 results

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

## ©️ US Copyright Records Search

**Pay-per-result access to the U.S. Copyright Office public catalog — registrations and recordations (assignments, transfers, security interests) as structured JSON. $0.10 per record. No Westlaw seat, no Copyright Office bulk-data ETL project, no per-search metering wall.**

The U.S. Copyright Office maintains the authoritative public record of copyright in the United States: every registered work, every recorded transfer of rights, and the chain of title that establishes who owns what. That record is the single source of truth IP attorneys cite in infringement litigation, that music and film rights teams walk to confirm a chain of ownership before a deal, and that publishing houses search before they reissue a back-catalog title. The catalog is public — but it lives behind a search UI built for one-off lookups, not for the bulk, programmatic, repeatable querying that a modern rights-clearance pipeline or a legal-AI ingestion job needs.

This actor turns that public catalog into a clean JSON API. Pass a free-text query across titles, authors, and claimants — optionally narrowed by work type, record type, and registration status — and get back structured records carrying the registration number, the registration date, the parties (authors and claimants), the work type, the record type, and a direct link back to the source record. Build a rights-clearance workflow, a due-diligence batch job, a copyright-watch alert, or feed the records straight into a legal-research model — all without standing up your own scraper against a Cloudflare-protected source.

### Why use this

The Copyright Office's public catalog is genuinely public, but it is not built to be queried at scale. The search front end is rate-paced, datacenter IPs are blocked at the edge by Cloudflare, and results come back as HTML pages designed for a human reading one record at a time. If you need to run the same author search every week, batch-check fifty titles before a catalog acquisition, or keep a watchlist of recorded assignments against a portfolio of marks and works, you end up either clicking through the UI by hand or building — and maintaining — a brittle scraper that breaks every time the source changes its markup or tightens its bot defenses.

This actor is that scraper, maintained for you, behind a stable JSON contract. You pass a query and filters; you get back records. Residential-proxy routing (required, because the source blocks datacenter IPs) is bundled into the per-record price — there is no separate proxy bill, no IP pool to manage, no Cloudflare challenge to solve. Because billing is pay-per-result, a search that returns nothing costs you nothing beyond the negligible actor-start event, and your cost is always a simple function of how many records you actually wanted.

### What you get

Each record returned by this actor is structured JSON populated from the U.S. Copyright Office public catalog wherever the source filing provides the field:

- `title` — the title of the registered or recorded work
- `typeOfWork` — the category of work (literary work, sound recording, motion picture, visual-arts work, musical work, etc.)
- `typeOfRecord` — whether the entry is a `registration`, a `recordation` (an assignment, transfer, or security interest filed against an existing work), or an `acquisition`
- `authors` — the author(s) of the work as named in the record
- `claimants` — the copyright claimant(s) — the party (or parties) in whom copyright is currently vested per the filing
- `registrationNumber` — the official Copyright Office registration number, the universal identifier for the work
- `registrationDate` — the date the registration was effective
- `recordUrl` — a direct deep link back to the source record in the public catalog for audit and verification

The schema is additive-only and stable across runs, so you can load records straight into a case-management system, a rights database, Snowflake, BigQuery, or Postgres without re-mapping on every refresh.

### Use cases

- **Pre-litigation copyright verification** — Before filing an infringement claim, confirm the asserted work is in fact registered (a prerequisite to suit for U.S. works under 17 U.S.C. §411), pull its registration number and effective date, and confirm the claimant of record. The `registrationNumber` and `registrationDate` fields are the exact inputs a complaint and a copyright-registration exhibit require.
- **Chain-of-title due diligence for M&A and catalog acquisitions** — When a buyer acquires a music catalog, a film library, or a publishing back-list, counsel must trace ownership through every recorded assignment. Filter `typeOfRecord=recordation` and batch-search every title in the target catalog to surface the transfers, security interests, and assignments filed against each work.
- **Music and film rights clearance** — Rights teams confirm who currently controls a song, master, or screenplay before licensing or sampling. Search by title or author, read the `claimants` field for the party of record, and follow `recordUrl` to the underlying filing.
- **Publishing reissue clearance** — Before reissuing an out-of-print title, confirm the registration, identify the current claimant, and surface any recorded transfers that moved the rights since first publication.
- **Copyright-watch and portfolio monitoring** — Run a scheduled search across the authors, claimants, or titles in your portfolio to catch newly recorded assignments or security interests filed against works you track — an early signal of a competitor's acquisition or a counterparty's financing.
- **Legal-AI and RAG ingestion** — Each record is JSON-flat and carries a source URL, making it drop-in fodder for a copyright-research model or a retrieval index over the public catalog.
- **Brand and anti-counterfeiting investigation** — Combine title and claimant searches to map the registered creative assets an adversary controls, complementing trademark and patent investigation.
- **Academic and policy research** — Quantify registration and recordation activity by work type over time for empirical IP scholarship.

### Sample output

```json
{
  "title": "Midnight in the Garden of Echoes",
  "typeOfWork": "Sound Recording",
  "typeOfRecord": "registration",
  "authors": ["Harlan Voss", "Echoes Recording Group LLC"],
  "claimants": ["Echoes Recording Group LLC"],
  "registrationNumber": "SR0000987654",
  "registrationDate": "2025-03-18",
  "recordUrl": "https://publicrecords.copyright.gov/detailed-record/SR0000987654"
}
````

A `recordation` entry — a recorded transfer against an existing work — looks like this:

```json
{
  "title": "Midnight in the Garden of Echoes",
  "typeOfWork": "Sound Recording",
  "typeOfRecord": "recordation",
  "authors": ["Harlan Voss"],
  "claimants": ["Aurora Catalog Holdings LP"],
  "registrationNumber": "V9912000345",
  "registrationDate": "2026-01-09",
  "recordUrl": "https://publicrecords.copyright.gov/detailed-record/V9912000345"
}
```

### Input parameters

| Parameter | Label | Description |
|---|---|---|
| `query` | Search query | Free-text search across titles, authors, and claimants. |
| `typeOfWork` | Type of work | Filter by work type (e.g. literary work, sound recording, motion picture, visual-arts work). |
| `typeOfRecord` | Type of record | Filter by `registration`, `recordation`, or `acquisition`. |
| `registrationStatus` | Registration status | Filter by registration status. |
| `maxResults` | Max results | Maximum number of records to return. |
| `useResidentialProxy` | Use residential proxy | Route through Apify residential proxy. Required — the source blocks datacenter IPs via Cloudflare. |
| `userAgent` | User-Agent override | Optional custom User-Agent header. |

### How to use

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("nexgendata/us-copyright-records-search").call(run_input={
    "query": "Echoes Recording Group",
    "typeOfRecord": "recordation",
    "useResidentialProxy": True,
    "maxResults": 100,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["registrationNumber"], item["claimants"])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/nexgendata~us-copyright-records-search/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "Echoes Recording Group",
    "typeOfRecord": "recordation",
    "useResidentialProxy": true,
    "maxResults": 100
  }'
```

Results stream into the Apify dataset, exportable as JSON, JSONL, CSV, or Excel. Schedule the actor via Apify's built-in scheduler to run a standing portfolio search daily or weekly, and wire a webhook to fire a Slack / Zapier / Make alert the moment a new recordation appears against a tracked work.

### Pricing

This actor runs on Apify's **pay-per-event (PPE)** model — you pay for results, not run-time:

- **$0.10 per record** — the primary event, charged once per record pushed to the dataset
- **Actor start** — a negligible one-time per-run event

No subscriptions, no seat licences, no minimums. Residential-proxy rotation is bundled into the per-record price.

#### Cost worked example

- A 50-title chain-of-title batch returning ~6 records each (~300 records) → ~$30
- A single author search returning 40 records → ~$4
- A weekly portfolio watch returning ~25 new recordations → ~$2.50/week

If a search matches nothing, you pay nothing beyond the actor-start event. Apify's free tier covers most experiments. Browse 200+ buyer-intent actors at https://apify.com/nexgendata?fpr=2ayu9b

### How this compares to Westlaw, LexisNexis, and Copyright Office bulk data

| Source | Cost | What you get |
|---|---|---|
| Westlaw IP / Cocatalog research | ~$100-$250+/seat/month, or per-search metering | Copyright records inside a broader research suite; export-restricted, not a programmatic feed |
| LexisNexis IP | Custom enterprise contract | Records within a litigation-research platform; no bulk JSON API for the copyright catalog |
| Copyright Office public catalog (DIY) | Free to read, but Cloudflare-blocked for datacenter IPs and rate-paced | Raw HTML, one record at a time; you build and maintain the scraper and the proxy layer |
| Copyright Office bulk-data sets | Free | Massive flat files requiring an ETL project to parse, index, and query |
| **US Copyright Records Search (this actor)** | **$0.10/record, no subscription** | **Filtered, structured JSON — title, authors, claimants, registration number/date, record type, source URL** |

If you need a full litigation-research workspace with shepardizing, briefs, and treatises, you still want Westlaw or Lexis. But if your workflow is rights clearance, chain-of-title due diligence, registration verification, or feeding a legal-AI index — and you want records as JSON for cents apiece instead of a per-seat research subscription — this actor is the right cost model.

### FAQ

**Q: Where does the data come from?**

A: The U.S. Copyright Office public records catalog — the official, government-maintained public record of copyright registrations and recordations. The `recordUrl` on every record links straight back to the source entry for verification.

**Q: What is the difference between a registration and a recordation?**

A: A `registration` is the original filing that establishes copyright in a work. A `recordation` is a document filed against an existing work to record a change — an assignment, a transfer of ownership, or a security interest. Use `typeOfRecord` to filter to whichever you need; chain-of-title work usually wants `recordation`.

**Q: Why is the residential proxy required?**

A: The source sits behind Cloudflare and blocks datacenter IP ranges. Routing through Apify's residential proxy (set `useResidentialProxy=true`) is necessary for reliable access; the cost is bundled into the per-record price.

**Q: Can I get the full deposit copy or the underlying assignment document?**

A: No. The public catalog exposes the metadata of the record — parties, work type, registration number and date, and the link to the catalog entry. Deposit copies and full recorded documents are obtained separately from the Copyright Office; the `recordUrl` is your starting point.

**Q: Are author and claimant lists complete?**

A: They reflect what the source filing names. Where a work has multiple authors or claimants, all named parties appear in the arrays; where the source omits a field, it is returned null or empty.

### Schema stability & versioning

This actor follows NexGenData's **additive-only schema** contract. New fields may be added at any time as new keys, defaulting to null for older runs. Existing fields are never renamed or removed without a major-version bump and an advance changelog notice. Field semantics — value sets, date formats — are never silently changed; if a change is required, a new field is added and the old one is kept for at least 90 days. You can build a production rights pipeline on this output without a Tuesday change breaking a Friday ETL job.

### Compliance & legal

- The actor reads the **public, government-published** U.S. Copyright Office records catalog — the same records any member of the public may search. Copyright registration records are a public record by statute.
- Requests route through Apify's compliant residential-proxy infrastructure with polite pacing.
- The actor does not collect, store, or transmit credentials, and accesses no authenticated or paywalled content.
- You are responsible for ensuring your downstream use complies with the source's terms of use and your jurisdiction's data-protection laws. Registration data is frequently cited in litigation and due diligence; confirm currency against the live record via `recordUrl` before relying on it for a legal filing.
- Consult counsel before bulk redistribution of compiled records.

### Related NexGenData actors

Part of NexGenData's **IP & Legal intelligence** cluster — pair this actor with:

- [US Court Opinions & Case Law Search](https://apify.com/nexgendata/courtlistener-court-opinions?fpr=2ayu9b) — 240,000+ federal & state opinions, for infringement case-law research
- [RECAP / PACER Docket Search](https://apify.com/nexgendata/recap-pacer-docket-search?fpr=2ayu9b) — federal docket lookups to track active copyright litigation
- [USPTO Patent Search](https://apify.com/nexgendata/uspto-patent-search?fpr=2ayu9b) — patent records to round out an IP portfolio map
- [Trademark Search](https://apify.com/nexgendata/trademark-search?fpr=2ayu9b) — US trademark records for brand-asset clearance
- [EUIPO eSearch Trademarks](https://apify.com/nexgendata/euipo-esearch-trademarks?fpr=2ayu9b) — EU trademark records for cross-border clearance
- [TTAB Trademark Opposition Tracker](https://apify.com/nexgendata/ttab-trademark-opposition-tracker?fpr=2ayu9b) — trademark opposition and cancellation proceedings

Browse the full 200+ actor catalog at **https://apify.com/nexgendata?fpr=2ayu9b**.

# Actor input Schema

## `query` (type: `string`):

Free-text search across titles, authors, and claimants.

## `typeOfWork` (type: `array`):

Filter by work type.

## `typeOfRecord` (type: `array`):

registration / recordation / acquisition.

## `registrationStatus` (type: `array`):

Filter by registration status.

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

Maximum number of records to return.

## `useResidentialProxy` (type: `boolean`):

Route through Apify residential proxy (required: source blocks datacenter IPs via Cloudflare).

## `userAgent` (type: `string`):

Optional custom User-Agent header.

## Actor input object example

```json
{
  "query": "Taylor Swift",
  "maxResults": 200,
  "useResidentialProxy": true
}
```

# 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 = {
    "query": "Taylor Swift"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/us-copyright-records-search").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 = { "query": "Taylor Swift" }

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/us-copyright-records-search").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 '{
  "query": "Taylor Swift"
}' |
apify call nexgendata/us-copyright-records-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/us-copyright-records-search",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "©️ US Copyright Records Search",
        "description": "Search U.S. Copyright Office registrations and recordations (assignments/transfers) with titles, authors, claimants, work type, registration numbers and dates. For IP attorneys, music/film/publishing rights teams, and due-diligence.",
        "version": "0.0",
        "x-build-id": "Bf7BArVFXiP5f4iHW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~us-copyright-records-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-us-copyright-records-search",
                "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/nexgendata~us-copyright-records-search/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-us-copyright-records-search",
                "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/nexgendata~us-copyright-records-search/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-us-copyright-records-search",
                "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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text search across titles, authors, and claimants."
                    },
                    "typeOfWork": {
                        "title": "Type of work",
                        "type": "array",
                        "description": "Filter by work type.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "music",
                                "text",
                                "sound_recording",
                                "sound_recording_music",
                                "motion_picture",
                                "visual_material",
                                "serial",
                                "computer_file",
                                "dramatic_work_choreography"
                            ]
                        }
                    },
                    "typeOfRecord": {
                        "title": "Type of record",
                        "type": "array",
                        "description": "registration / recordation / acquisition.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "registration",
                                "recordation",
                                "acquisition"
                            ]
                        }
                    },
                    "registrationStatus": {
                        "title": "Registration status",
                        "type": "array",
                        "description": "Filter by registration status.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "published",
                                "unpublished",
                                "registered"
                            ]
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum number of records to return.",
                        "default": 200
                    },
                    "useResidentialProxy": {
                        "title": "Use residential proxy",
                        "type": "boolean",
                        "description": "Route through Apify residential proxy (required: source blocks datacenter IPs via Cloudflare).",
                        "default": true
                    },
                    "userAgent": {
                        "title": "User-Agent override",
                        "type": "string",
                        "description": "Optional custom User-Agent header."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
