# Getty Museum Open Content Scraper (`crawlerbros/getty-museum-open-content-scraper`) Actor

Scrape the J. Paul Getty Museum's open-access art collection (160k+ CC0 works). Search by artist/title/keyword, browse by curatorial department or classification, or fetch by object ID/URL. Full metadata plus direct high-resolution CC0 image download links.

- **URL**: https://apify.com/crawlerbros/getty-museum-open-content-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools
- **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 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

## Getty Museum Open Content Scraper

Scrape the J. Paul Getty Museum's open-access art collection — 160,000+ CC0
artworks spanning antiquities, drawings, manuscripts, paintings, photographs,
and sculpture & decorative arts. Search by artist, title, or keyword; browse
by curatorial department or classification/object type; or fetch specific
artworks by ID or collection URL. Every record includes full curatorial
metadata (artist, date, medium, dimensions, provenance, exhibition history)
plus a direct high-resolution CC0 image download link. No login, no API key,
no paid proxy required.

### What this actor does

- **Four modes:** `search` (artist/title/keyword), `byDepartment` (curatorial
  department), `byClassification` (object-type taxonomy), `byId` (direct
  lookup by object ID or collection URL)
- **Combinable filters:** department and classification can also be layered
  on top of a text search to narrow results further
- **Full curatorial record:** title, artist, nationality & life dates,
  display date, medium, dimensions, credit line, culture, place created,
  description, department, classification, exhibition history, provenance
  (past owners)
- **Direct image access:** full-resolution image download URL, a 400px-wide
  thumbnail, and the per-image copyright status
- **Empty fields are omitted** — every record contains only the data Getty
  actually published for that artwork

### Output per artwork

- `objectId`, `uuid` — Getty's public object identifier and internal record ID
- `title`, `alternateTitle`, `accessionNumber`
- `artist`, `artistNationalityAndDates`
- `displayDate`, `dateEarliest`, `dateLatest`
- `medium`, `objectType`, `dimensions`
- `creditLine`, `cultureStatement`, `placeCreated`, `description`
- `department` — one of Antiquities, Drawings, Manuscripts, Paintings,
  Photographs, Sculpture and Decorative Arts
- `classification`, `classifications[]` — object-type taxonomy term(s)
- `exhibitionHistory[]` — exhibitions the work has appeared in
- `provenance[]` — prior owners / collections, in acquisition order
- `imageUrl` — full-resolution downloadable JPEG
- `thumbnailUrl` — 400px-wide JPEG
- `imageCopyrightStatus` — e.g. "No Copyright" (CC0/public domain) for the image itself
- `metadataLicense` — CC0 1.0 Universal (applies to all cataloging metadata)
- `sourceUrl` — the artwork's page on getty.edu
- `apiUrl` — the artwork's canonical Linked Open Data record
- `recordType: "artwork"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byDepartment` / `byClassification` / `byId` |
| `searchQuery` | string | `Van Gogh` | Free-text match against artwork titles and artist names |
| `department` | string (enum) | – | Curatorial department; required for `byDepartment`, optional filter otherwise |
| `classification` | string (enum) | – | Object-type taxonomy term; required for `byClassification`, optional filter otherwise |
| `objectIds` | array | – | Object slugs, UUIDs, or full collection URLs (mode=`byId`) |
| `requireImage` | boolean | `false` | Only emit artworks that have a downloadable image |
| `maxItems` | integer | `20` | Hard cap on emitted records (1–300) |

#### Example: search with a department filter

```json
{
  "mode": "search",
  "searchQuery": "portrait",
  "department": "paintings",
  "maxItems": 25
}
````

#### Example: browse a classification

```json
{
  "mode": "byClassification",
  "classification": "sculpture",
  "maxItems": 50
}
```

#### Example: fetch specific artworks

```json
{
  "mode": "byId",
  "objectIds": [
    "103QZ9",
    "https://www.getty.edu/art/collection/object/103RDF"
  ]
}
```

### Use cases

- **Digital humanities / art history research** — bulk-export curatorial
  metadata and provenance for a department, artist, or period
- **CC0 image sourcing** — pull direct high-resolution download links for
  editorial, educational, or generative-AI training use
- **Museum data aggregation** — combine with other open-collection sources
  (Smithsonian, Rijksmuseum, Met) into a unified art dataset
- **Provenance / collecting-history research** — trace an artwork's chain of
  ownership across auctions and collections
- **Exhibition history tracking** — see which shows a given work has traveled to

### Data source / limitations

This actor uses Getty's public **Museum Collection Linked Open Data API**
(`data.getty.edu/museum/collection`, a Linked.Art / CIDOC-CRM model) together
with its public SPARQL endpoint for search and browse queries, and the
server-rendered `getty.edu/art/collection/object/{id}` page for resolving a
public object ID to its underlying record. No authentication, API key, or
paid proxy is required for any mode.

- **Metadata license:** CC0 1.0 Universal (public domain dedication) —
  reflected in every record's `metadataLicense` field.
- **Image rights vary per artwork.** Getty publishes a per-image
  `imageCopyrightStatus` (most are "No Copyright" / public domain under
  Getty's Open Content Program, but a minority carry third-party
  restrictions) — always check this field before reusing an image
  commercially.
- **"Medium" is not a fully enumerable facet.** Unlike department and
  classification, Getty does not publish a small fixed list of material/medium
  values across the whole collection, so `medium` is returned as free text
  per object rather than offered as a filter dropdown.
- Written descriptions and artist biographies may include third-party
  copyrighted text (per Getty's own usage guidelines); Getty does not
  authorize redistribution of that subset. See the object's `sourceUrl` for
  the original context.

### FAQ

**Is this the same as Getty's public website search?** It queries the same
underlying dataset that powers getty.edu/art/collection, using Getty's own
public Linked Open Data API rather than scraping rendered web pages.

**Do I need a Getty API key?** No. The Museum Collection API and its SPARQL
endpoint are fully public and keyless.

**Can I filter by more than one thing at once?** Yes — `department` and
`classification` can both be combined with `searchQuery` in `search` mode, or
with each other, to narrow results.

**What departments are available?** Antiquities, Drawings, Manuscripts,
Paintings, Photographs, and Sculpture and Decorative Arts — the Getty
Museum's six curatorial departments.

**Why do some artworks have `artist: "Unknown"`?** That reflects Getty's own
cataloging — many historical photographs and works have no attributable maker
on record.

**Can I use the images commercially?** Check `imageCopyrightStatus` on each
record. Most Getty Museum images are released under its Open Content Program
(no restrictions), but always verify per artwork before commercial use.

**How current is the data?** The API reflects Getty's live collection
database — the same source that powers their public website.

# Actor input Schema

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

What to fetch.

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

Free-text query matched against artwork titles and artist names (mode=search).

## `department` (type: `string`):

Filter to a Getty Museum curatorial department. Required for mode=byDepartment; optional extra filter for mode=search/byClassification.

## `classification` (type: `string`):

Filter to a Getty classification/object-type taxonomy term. Required for mode=byClassification; optional extra filter for mode=search/byDepartment.

## `objectIds` (type: `array`):

Getty object slugs (e.g. `103QZ9`), UUIDs, or full collection URLs (e.g. `https://www.getty.edu/art/collection/object/103QZ9`).

## `requireImage` (type: `boolean`):

Skip records that have no downloadable image available.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "Van Gogh",
  "objectIds": [],
  "requireImage": false,
  "maxItems": 20
}
```

# Actor output Schema

## `artworks` (type: `string`):

Dataset containing all scraped Getty Museum artwork 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": "Van Gogh",
    "objectIds": [],
    "requireImage": false,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/getty-museum-open-content-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": "Van Gogh",
    "objectIds": [],
    "requireImage": False,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/getty-museum-open-content-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": "search",
  "searchQuery": "Van Gogh",
  "objectIds": [],
  "requireImage": false,
  "maxItems": 20
}' |
apify call crawlerbros/getty-museum-open-content-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Getty Museum Open Content Scraper",
        "description": "Scrape the J. Paul Getty Museum's open-access art collection (160k+ CC0 works). Search by artist/title/keyword, browse by curatorial department or classification, or fetch by object ID/URL. Full metadata plus direct high-resolution CC0 image download links.",
        "version": "1.0",
        "x-build-id": "cMiK2Of4YYKIqTSnr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~getty-museum-open-content-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-getty-museum-open-content-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~getty-museum-open-content-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-getty-museum-open-content-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~getty-museum-open-content-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-getty-museum-open-content-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": [
                            "search",
                            "byDepartment",
                            "byClassification",
                            "byId"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text query matched against artwork titles and artist names (mode=search).",
                        "default": "Van Gogh"
                    },
                    "department": {
                        "title": "Curatorial department",
                        "enum": [
                            "antiquities",
                            "drawings",
                            "manuscripts",
                            "paintings",
                            "photographs",
                            "sculptureAndDecorativeArts"
                        ],
                        "type": "string",
                        "description": "Filter to a Getty Museum curatorial department. Required for mode=byDepartment; optional extra filter for mode=search/byClassification."
                    },
                    "classification": {
                        "title": "Classification / object type",
                        "enum": [
                            "photographs",
                            "vessels",
                            "coins",
                            "manuscripts",
                            "sculpture",
                            "jewelry",
                            "implements",
                            "books",
                            "architecture",
                            "drawings",
                            "paintings",
                            "decorativeArts",
                            "miscellaneous",
                            "texts",
                            "armor",
                            "prints",
                            "timeBasedMedia",
                            "siteInstallations"
                        ],
                        "type": "string",
                        "description": "Filter to a Getty classification/object-type taxonomy term. Required for mode=byClassification; optional extra filter for mode=search/byDepartment."
                    },
                    "objectIds": {
                        "title": "Object IDs / URLs (mode=byId)",
                        "type": "array",
                        "description": "Getty object slugs (e.g. `103QZ9`), UUIDs, or full collection URLs (e.g. `https://www.getty.edu/art/collection/object/103QZ9`).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "requireImage": {
                        "title": "Only artworks with an image",
                        "type": "boolean",
                        "description": "Skip records that have no downloadable image available.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```