# US Copyright Office Scraper (`crawlerbros/us-copyright-office-scraper`) Actor

Scrape the US Copyright Office Public Records System (COINS) - 60M+ copyright registrations, recordations and card-catalog records. Search by title, keyword, owner/claimant, author or registration number; get full registration metadata, claimants, authors, dates, and catalog detail.

- **URL**: https://apify.com/crawlerbros/us-copyright-office-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Office Scraper

Scrape **the US Copyright Office Public Records System (COINS)** — the official public catalog of copyright registrations, recordations and card-catalog records (1938–today, 60M+ records). Search by keyword / title, registration number, owner/claimant or author, and get the full registration record: registration numbers, titles, claimants, authors, dates of creation/registration/publication, type of work, renewal info, correspondence addresses, and card-catalog images. HTTP-only via the public COINS JSON API. No auth, no proxy required.

### What this actor does

- **Four modes:** `search`, `searchByNumber`, `searchByOwner`, `searchByAuthor`
- **Full record detail:** every emitted record is enriched with the official detailed-record payload (claimants with addresses, author statements, imprint, basis of claim, renewal/previous-registration info, dates)
- **Filters:** type of work, registration class (TX/PA/SR/VA/RE/MW/PRE...), registration status, record type (registration/recordation), recordation item type, system of origin, date range on 6 date axes, must-contain keyword, sort
- **Card-catalog coverage:** pre-1978 card-catalog records include scanned card images from the Library of Congress tile server
- **Empty fields are omitted**

### Output per record

- `publicRecordsId` — COINS record ID (e.g. `voyager_16089852`, `card_catalog_...`)
- `title`, `titleProper`, `variantTitles[]`
- `registrationNumber`, `copyrightNumber`, `registrationNumbers[]`, `cancelledRegistrationNumbers[]`, `previousRegistrationNumbers[]`
- `registrationClass`, `registrationStatus`, `typeOfWork`, `typeOfWorkEnglish`, `allTypesOfWork[]`
- `claimants[]`, `claimantAddresses[]`, `primaryClaimant`, `authors[]`, `authorDetails[]` (domicile, citizenship, authorship), `primaryAuthor`
- `registrationDate`, `dateOfCreation`, `dateOfPublication`, `publicationYear`, `representativeDate`, `applicationDate`, `depositReceivedDate`
- `basisOfClaim[]`, `imprint[]`, `physicalDescription`, `preexistingMaterial`, `materialExcluded`, `rightsAndPermissions`, `copyrightNote`
- Recordations: `recordationNumber`, `recordationDate`, `recordationItemType`, `recordationNumberRange`, `numberOfPages`, `serviceRequestNumber`, `parentDocumentTitle`
- Card catalog: `titleOfWork`, `drawerName`, `timePeriod`, `cardIdentifiers[]`, `cardImageUrls[]` (scanned card images), `feeDate`
- `displayNames` — persons/organizations with roles (author, claimant)
- `sourceUrl` — official COINS detailed-record page, `recordType`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `searchByNumber` / `searchByOwner` / `searchByAuthor` |
| `searchQuery` | string | `harry potter` | Free-text query (mode=search) |
| `searchField` | string | `keyword` | `keyword` (all fields) or `title` only |
| `registrationNumber` | string | – | Exact number lookup (mode=searchByNumber), e.g. `TX0005739644`, `V3632D194` |
| `ownerQuery` | string | – | Claimant/owner name (mode=searchByOwner) |
| `authorQuery` | string | – | Author name (mode=searchByAuthor) |
| `workType` | string | – | Type of work (literary, musical, visual arts, performing arts, sound recordings, motion pictures, software...) |
| `registrationClass` | string | – | Registration class (TX, PA, SR, VA, RE, MW, PR, ...) |
| `registrationStatus` | string | – | `published` / `unpublished` / `unspecified` |
| `recordType` | string | – | `registration` / `recordation` |
| `recordationItemType` | string | – | Assignment, mortgage/security agreement, DMCA filing, termination notice, licenses... |
| `systemOfOrigin` | string | – | `voyager` (post-1977) / `card_catalog` (pre-1978) |
| `dateRangeFrom` / `dateRangeTo` | string | – | Date range `YYYY-MM-DD` on the field in `dateField` |
| `dateField` | string | `registration_date_as_date` | Effective date of registration, publication, creation, certification, recordation, or representative date |
| `containsKeyword` | string | – | Only emit records whose title, claimants, authors or numbers contain this substring |
| `sortBy` | string | `relevancy` | Relevance / title / date / copyright number / latest transaction date |
| `sortOrder` | string | `asc` | `asc` / `desc` |
| `maxResults` | int | `50` | Hard cap (1–1000) |
| `proxyConfiguration` | object | – | Optional; only used automatically if the COINS API rate-limits or blocks direct requests |

#### Example: search a famous title

```json
{
  "mode": "search",
  "searchQuery": "harry potter",
  "maxResults": 5
}
```

#### Example: exact registration number lookup

```json
{
  "mode": "searchByNumber",
  "registrationNumber": "TX0005739644"
}
```

#### Example: everything recorded by a studio, filtered by work type and date

```json
{
  "mode": "searchByOwner",
  "ownerQuery": "Warner Brothers",
  "workType": "motion_picture",
  "dateRangeFrom": "2000-01-01",
  "dateRangeTo": "2010-12-31",
  "dateField": "registration_date_as_date",
  "maxResults": 100
}
```

#### Example: every book a specific author registered in a year

```json
{
  "mode": "searchByAuthor",
  "authorQuery": "Rowling",
  "registrationClass": "TX",
  "dateRangeFrom": "1997-01-01",
  "dateRangeTo": "2007-12-31",
  "maxResults": 50
}
```

### Use cases

- **Licensing & rights research** — confirm who owns a registered work before negotiating
- **Publishing & entertainment legal teams** — pull registration numbers, dates and renewal history for due-diligence
- **Music / film libraries** — verify sound-recording (SR) and performing-arts (PA) registrations and recordation documents
- **Academic research** — study registration trends by class, date and claimant across 60M+ records
- **Card-catalog digitization projects** — collect pre-1978 registration metadata plus scanned card images
- **IP portfolio monitoring** — track new registrations and assignments by claimant or author

### Data Source

The US Copyright Office Public Records System ("COINS") at [publicrecords.copyright.gov](https://publicrecords.copyright.gov/). This actor uses the same public JSON API the website itself calls (`api.publicrecords.copyright.gov`), so no scraping of rendered pages is required and no login is needed. Data is refreshed by the Copyright Office via its nightly export pipeline; every record carries `sourceDate` (export date) and a `sourceUrl` link to the official detail page for verification. This actor is not affiliated with or endorsed by the US Copyright Office.

### Limitations

- **No auth-walled axes:** all modes (`search`, `searchByNumber`, `searchByOwner`, `searchByAuthor`) hit public endpoints — there is no private-registration or examiner-only data exposed.
- **Card-catalog records are lighter:** pre-1978 card-catalog records lack modern fields (claimant addresses, basis of claim, imprint) by design — the source has no such data; scanned card images are provided instead.
- **Number formats are emitted as-is:** registration-number display strings come straight from the Copyright Office (leading-zero quirks, `I pub. 34656` style card-catalog numbers) to stay faithful to the official record.
- **Search field limits:** `dateField` supports the six date axes the public API exposes; the API does not index dates before 1938 (the card-catalog era uses `representative_date`).
- **API stability:** the public COINS API occasionally rate-limits or returns transient 5xx under heavy load; the actor retries with backoff and can use an optional proxy if direct access is blocked.
- **Not affiliated:** this actor is a third-party tool and is not affiliated with or endorsed by the US Copyright Office.

### FAQ

**Is the data free?**  Yes. The US Copyright Office publishes these public records free of charge; the actor uses the same public endpoint the COINS website uses.

**What's the difference between a registration, a recordation and a card-catalog record?**  A *registration* is an original copyright claim filed with the Office (post-1978 records in the electronic catalog). A *recordation* is a document filed with the Office (assignment, security agreement, termination notice, license...). *Card-catalog* records are scanned pre-1978 registration cards. Records carry `recordType` so you can tell them apart.

**Why are some registration numbers missing a leading zero?**  The Copyright Office's own display strings are emitted as-is (`I pub. 34656` for card-catalog records, `TX0005739644` style for modern ones). We also emit the parsed variants where the API provides them.

**How do date filters work?**  `dateRangeFrom`/`dateRangeTo` are applied to the date axis you pick in `dateField` (default: effective date of registration). Use `YYYY-MM-DD`.

**Does `containsKeyword` work on all fields?**  It filters on the record's title, variant titles, claimants, authors and copyright/registration numbers (case-insensitive substring).

**How fresh is the data?**  The Copyright Office refreshes the public system roughly daily through its export pipeline; each record's `sourceDate` and `sourceFile` show which export it came from.

**Can I get the official certificate?**  The actor returns the metadata and a link to the official detail page. Official certificates can be ordered from the Copyright Office directly.

**Do I need a proxy?**  No. The public API is directly accessible. If the API rate-limits your run, you may optionally configure Apify proxy and it will be engaged automatically.

# Actor input Schema

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

What to fetch.

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

Free-text query — title, name, number or any keyword (mode=search).

## `searchField` (type: `string`):

Which indexed field the search query is matched against (mode=search).

## `registrationNumber` (type: `string`):

Copyright registration, recordation or SR number, e.g. `TX0005739644`, `PAu004203637`, `RE0000082251`, `V3632D194`, `SR0000079638`.

## `ownerQuery` (type: `string`):

Name of the copyright claimant/owner, e.g. `Warner Brothers`.

## `authorQuery` (type: `string`):

Name of the author/creator, e.g. `Rowling`.

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

Restrict to a specific type of work.

## `registrationClass` (type: `string`):

Restrict to a US Copyright Office registration class.

## `registrationStatus` (type: `string`):

Restrict by published / unpublished status.

## `recordType` (type: `string`):

Restrict to registrations or recordations.

## `recordationItemType` (type: `string`):

Restrict to a type of recorded document (assignments, security agreements, DMCA filings, terminations, licenses...).

## `systemOfOrigin` (type: `string`):

Restrict to a source catalog: post-1977 electronic records or pre-1978 card catalog.

## `dateRangeFrom` (type: `string`):

Earliest date of the range (YYYY-MM-DD), applied to the field selected in `dateField`.

## `dateRangeTo` (type: `string`):

Latest date of the range (YYYY-MM-DD), applied to the field selected in `dateField`.

## `dateField` (type: `string`):

Which record date the date range is applied to.

## `containsKeyword` (type: `string`):

Only emit records whose title, claimants, authors or registration number contain this substring.

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

Field used to order results.

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

Ascending or descending order.

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

Hard cap on emitted records.

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

Optional proxy. Only used automatically if the Copyright Office API rate-limits or blocks direct requests.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "harry potter",
  "searchField": "keyword",
  "dateField": "registration_date_as_date",
  "sortBy": "relevancy",
  "sortOrder": "asc",
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

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

Dataset containing all scraped copyright 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 = {
    "mode": "search",
    "searchQuery": "harry potter",
    "searchField": "keyword",
    "dateField": "registration_date_as_date",
    "sortBy": "relevancy",
    "sortOrder": "asc",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/us-copyright-office-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": "search",
    "searchQuery": "harry potter",
    "searchField": "keyword",
    "dateField": "registration_date_as_date",
    "sortBy": "relevancy",
    "sortOrder": "asc",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/us-copyright-office-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": "search",
  "searchQuery": "harry potter",
  "searchField": "keyword",
  "dateField": "registration_date_as_date",
  "sortBy": "relevancy",
  "sortOrder": "asc",
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call crawlerbros/us-copyright-office-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/us-copyright-office-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5d2jNqlRNCSajxh9e/builds/YcesLV6HgsePsfbAk/openapi.json