# Art Institute Print Catalog — Object Metadata (`nexgensignal/artic-print-catalog-records`) Actor

Art Institute of Chicago print-catalog metadata (api.artic.edu) as clean per-record data - title, artist, date, medium, dimensions and public-domain flag. CC0 metadata only, no images/IIIF. $0.05 per record.

- **URL**: https://apify.com/nexgensignal/artic-print-catalog-records.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 print catalog records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Art Institute Print Catalog — Object Metadata

Turn the Art Institute of Chicago's public API into clean, per-record print-catalog metadata - one row per print object with title, artist, date, medium, dimensions and a public-domain flag, ready for collection-data buyers to enrich print inventories.

Each artwork from the Art Institute of Chicago public API becomes **one clean, flat record** with the
public-domain flag normalized to a real boolean, a stable `record_id` (the object id), and provenance
stamped on every row: source, endpoint, the CC0 notice, attribution, a UTC retrieval timestamp and an
interpretation caveat.

### What one record represents

The source is the **Art Institute of Chicago public API** (`api.artic.edu`), filtered to the **print**
artwork type. Each record is **one print object**: its object id, title, the historical artist
attribution line, display date, medium, dimensions, artwork type, classification, curatorial department,
place of origin, and whether the object itself is public domain. It is exactly the metadata a collection-
data buyer needs to enrich a print inventory.

### Coverage and volume

The print artwork type matches **48,203** objects. The Art Institute search API caps a single query at
**10,000 accessible results**, so a single unfiltered run delivers up to that 10,000-object slice.

**Live: 48,203 print matches, of which the source makes a 10,000-object slice accessible per query - matches the Wave-3 index figure (a 10,000 slice of 48,203) exactly.**

To reach the whole 48,203-object set, use the **Year from / Year to** inputs: the Actor adds a date
range to the search (verified live — for example prints made 1800-1850 return 5,818 objects, comfortably
under the cap), so you can walk the full match set in year-range slices, each below the 10,000 limit.

### Licence and attribution

The Art Institute releases its artwork **metadata under CC0** (a public-domain dedication) — free to use
without restriction. This Actor delivers metadata only: the free-text `description` field (which the API
licenses separately under CC BY) and **all images and IIIF identifiers are excluded**, so nothing outside
the CC0 metadata is redistributed. The full notice travels on every record:

> Art Institute of Chicago (api.artic.edu). Artwork metadata released under CC0 (public-domain dedication). The free-text description field and all images/IIIF identifiers are excluded; no image, image URL or IIIF id is delivered.

The attribution — `Art Institute of Chicago (api.artic.edu)` — is present on every record, and the API's terms of use are the
governing reference for the metadata.

### Interpretation caveat

Print catalog metadata (artwork type Print). is\_public\_domain flags whether the object itself is public domain. artist\_display is a historical attribution line; credit-line, provenance and image fields are excluded. The source caps a single query at 10,000 accessible results of 48,203 print matches - use the year range to partition beyond the cap.

Values are reproduced verbatim from the API; the Actor never rescales or rewrites a field.

### Person-data policy

`artist_display` is a **historical artist attribution** on a catalogued (largely public-domain) object -
it is part of the object record and is kept. Every other person-type field is excluded: the credit-line
(which names donors), provenance text, and any cataloguer field are **never selected**, and no image or
IIIF identifier is delivered. A per-record assertion enforces that allow-list (verified with a planted-
field test). This is object metadata about artworks, not data about living people.

### Data quality and freshness

`is_public_domain` is delivered as a real boolean. Every run re-reads the live API, so the data is as
fresh as the museum's catalogue, and each record's `observed_at` stamp records when it was retrieved.
Delivery is in the API's relevance order and keyed on the stable object id, so the dataset is safe to
diff, deduplicate or upsert. The run's `RUN_RECEIPT` records the total match count and the 10,000 cap
alongside how many records were delivered and charged.

### Provenance and compliance

Every run reads `api.artic.edu/robots.txt` at runtime; the gate result (URL, status, byte length,
SHA-256 of the policy) is written to the run's `RUN_RECEIPT`. The API is keyless. The Actor never
bypasses a block or fetches through a mirror, and it stops cleanly when the source returns the 10,000-
result cap.

### Inputs

- **Year from / Year to** (optional) - a date range to partition the catalogue and reach beyond the
  10,000-per-query cap.
- **Maximum records** (`maxRecords`) - hard cap on records delivered and billed (at most 10,000 per query).

### Output

Records land in the Actor's default dataset and export as JSON, CSV, Excel or via the Apify API. A
tabular **overview view** surfaces object id, title, artist, date, medium, type, classification,
department and the public-domain flag.

### Fields in detail

The record leads with `record_id` and `object_id`, then `title`, `artist_display`, `date_display`,
`medium_display`, `dimensions`, `artwork_type`, `classification`, `department`, `place_of_origin` and the
boolean `is_public_domain`. The provenance block closes every record, so a single row is self-describing
and audit-ready. Because the object id is stable, this dataset joins cleanly onto any collection system
that already stores Art Institute ids.

### Scaling and limits

Set **Maximum records** low to sample cheaply, or up to the 10,000-per-query cap for a full slice. The
Actor pages the API and delivers incrementally, so memory stays flat, and you are billed only for what is
delivered. The one hard boundary is the source's own 10,000-result cap on a single query; to pull the
whole 48,203-object print corpus, run the Actor once per year range (for example 1700-1799, 1800-1849,
1850-1899, and so on) so each slice stays under the cap, then concatenate - every record already carries
its stable object id, so the slices deduplicate cleanly. Because the catalogue changes slowly, a
scheduled monthly run is enough to keep a downstream table current; each run re-stamps `observed_at`.

### Sibling Actors

This Actor is a **museum-metadata** cell — a new domain for the fleet. It shares its engineering - the
runtime robots gate, push-then-charge billing and verbatim-value discipline - with the fleet's other
public-data records Actors.

### Sample output

![Sample output — Art Institute Print Catalog — Object Metadata](https://api.apify.com/v2/key-value-stores/IXCaMKjxSmUTLHhmq/records/artic-print-catalog-records.png)

*Real rows from a live run of this actor (first 5 rows, selected columns).*

One full record from the same run, exactly as delivered:

```json
{
  "object_id": 89503,
  "title": "Under the Wave off Kanagawa (Kanagawa oki nami ura), also known as The Great Wave, from the series \"Thirty-Six Views of Mount Fuji (Fugaku sanjurokkei)\"",
  "artist_display": "Katsushika Hokusai 葛飾 北斎\nJapanese, 1760-1849",
  "date_display": "1830/33",
  "medium_display": "Color woodblock print; oban",
  "dimensions": "25.4 × 37.6 cm (10 × 14 3/4 in.)",
  "artwork_type": "Print",
  "classification": "woodblock print",
  "department": "Arts of Asia",
  "place_of_origin": "Japan",
  "is_public_domain": true,
  "record_id": "89503",
  "source": "Art Institute of Chicago (api.artic.edu)",
  "source_dataset": "artworks/search",
  "licence": "Art Institute of Chicago (api.artic.edu). Artwork metadata released under CC0 (public-domain dedication). The free-text description field and all images/IIIF identifiers are excluded; no image, image URL or IIIF id is delivered.",
  "attribution": "Art Institute of Chicago (api.artic.edu)",
  "caveat": "Print catalog metadata (artwork type Print). is_public_domain flags whether the object itself is public domain. artist_display is a historical attribution line; credit-line, provenance and image fields are excluded. The source caps a single query at 10,000 accessible results of 48,203 print matches - use the year range to partition beyond the cap.",
  "observed_at": "2026-09-25T17:17:49Z"
}
```

### Pricing

This Actor uses Apify's pay-per-event model: a flat **$0.05 per record** actually delivered to the
dataset, and nothing else — no monthly rental, no per-run base fee, no compute charge. Deliver 40
records and you pay $2.00; deliver 10,000 and you pay $500.00. Billing is wired *after* delivery — each
record is pushed first and only then does the per-record event fire — so a mid-run failure can only
ever under-charge you, never over-charge. Use **Maximum records** to cap spend precisely.

### Typical uses

Enrich a print inventory with titles, artists, dates, media and dimensions; screen a collection for
public-domain objects; build a research or catalogue reference; partition the full print corpus by year
for a complete pull; or feed a collection-management or art-market model with clean object metadata.

### What this Actor does not do

It does not deliver images, image URLs or IIIF identifiers (CC0 covers metadata only); it does not
include credit-line, provenance or cataloguer fields; and it does not alter any published value. It gives
you faithful, CC0, analysis-ready object metadata - one row per print - with a provenance trail you can
audit on every run. Every field is the museum's own catalogue value, reproduced exactly, so the record is
as authoritative as the source and needs no reconciliation before you load it.

# Actor input Schema

## `yearFrom` (type: `string`):

Optional start year. The source caps a single query at 10,000 results; set a year range to partition the full match set (e.g. 1800-1850) and reach beyond the cap.

## `yearTo` (type: `string`):

Optional end year (used with Year from).

## `maxRecords` (type: `integer`):

Maximum records delivered and billed (capped at the source's 10,000 accessible per query).

## Actor input object example

```json
{
  "maxRecords": 500
}
```

# Actor output Schema

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

The delivered Art Institute print catalog record.

# 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 = {
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/artic-print-catalog-records").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 = { "maxRecords": 500 }

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/artic-print-catalog-records").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 '{
  "maxRecords": 500
}' |
apify call nexgensignal/artic-print-catalog-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/artic-print-catalog-records"
        }
    }
}
```

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/OvURQSyBiagd7agzh/builds/OjsPZgsBhPCKC1HF9/openapi.json