# Met Museum Collection Scraper — Art, Artists & Images (`compute-edge/met-museum-collection-scraper`) Actor

Extract artworks from the Metropolitan Museum of Art Collection API. Get title, artist, date, medium, department, classification, culture, public-domain status, images, and credit lines. Search by keyword or department. Clean JSON for art research and catalogs.

- **URL**: https://apify.com/compute-edge/met-museum-collection-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **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. 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

## Met Museum Collection Scraper — Art, Artists & Images

Extract structured artwork data from the **Metropolitan Museum of Art Collection API** — the Met's official open-access API covering 500,000+ objects spanning 5,000 years of human creativity. This Actor lets you search and browse the Met's collection programmatically, returning artist details, artwork metadata, culture, classification, and high-resolution image URLs in clean JSON format.

The Metropolitan Museum of Art's open-access initiative makes over 490,000 public-domain works freely available with zero authentication. Whether you're building an art history dataset, populating a RAG pipeline with cultural knowledge, or researching by department, this Actor gives you structured, ready-to-use data.

### Key Features

- **Keyword search** — Search the full Met collection by any term (e.g., "impressionism", "ancient egypt", "samurai armor")
- **Department filtering** — Narrow results to specific museum departments (European Paintings, Asian Art, Modern Art, and 17 more)
- **No authentication required** — The Met's public API requires no API key or credentials
- **Concurrency-optimized fetching** — Fetches 5 object details in parallel for fast throughput
- **Public domain flag** — Each record includes `isPublicDomain` to identify freely reusable images
- **Image URLs included** — Primary high-resolution and small image URLs for every object that has them
- **Graceful error handling** — Skips unavailable objects without failing the run
- **Configurable result count** — Return 1 to 1,000 records per run

### Output Data Fields

| Field | Type | Description |
|-------|------|-------------|
| `objectID` | integer | Unique Met Museum object identifier |
| `title` | string | Artwork title |
| `artist` | string | Artist display name (from `artistDisplayName`) |
| `artistNationality` | string | Artist's nationality (e.g., "American", "Dutch") |
| `objectDate` | string | Date or date range of the artwork (e.g., "1889", "ca. 1550–60") |
| `medium` | string | Materials used (e.g., "Oil on canvas", "Bronze") |
| `department` | string | Museum department (e.g., "European Paintings") |
| `classification` | string | Object classification (e.g., "Paintings", "Sculpture") |
| `culture` | string | Cultural origin (e.g., "French", "Roman", "Egyptian") |
| `isPublicDomain` | boolean | Whether the image is in the public domain and freely reusable |
| `primaryImage` | string | URL to the full-resolution primary image |
| `objectURL` | string | Link to the object's page on metmuseum.org |
| `accessionYear` | string | Year the object entered the Met's collection |
| `creditLine` | string | Donor/acquisition credit line |

### How to Scrape Met Museum Data

Follow these steps to extract Metropolitan Museum of Art collection data using this Actor:

1. Navigate to the **Met Museum Collection Scraper** Actor page on the Apify Store.
2. Click **Try for free** or **Start** to open the input form.
3. (Optional) Enter a **Search Query** to find specific artworks — try "van gogh", "ancient greek vase", or "impressionist landscape".
4. (Optional) Enter a **Department ID** to restrict results to one department. For example, enter `11` for European Paintings or `6` for Asian Art.
5. Set **Max Results** to control how many records are returned (default: 50, max: 1,000).
6. Leave all fields blank to browse the full collection (returns the first `maxResults` objects by ID).
7. Click **Start** to launch the Actor. Most runs complete in under 2 minutes.
8. Once the run finishes, open the **Dataset** tab to view results.
9. Download your data as **JSON**, **CSV**, or **Excel** using the export buttons.

#### Department ID Reference

| ID | Department Name |
|----|----------------|
| 1 | American Decorative Arts |
| 3 | Ancient Near Eastern Art |
| 4 | Arms and Armor |
| 5 | Arts of Africa, Oceania, and the Americas |
| 6 | Asian Art |
| 7 | The Cloisters |
| 8 | The Costume Institute |
| 9 | Drawings and Prints |
| 10 | Egyptian Art |
| 11 | European Paintings |
| 12 | European Sculpture and Decorative Arts |
| 13 | Greek and Roman Art |
| 14 | Islamic Art |
| 15 | The Robert Lehman Collection |
| 17 | Medieval Art |
| 18 | Musical Instruments |
| 19 | Photographs |
| 21 | Modern and Contemporary Art |

### Input Example

```json
{
    "q": "sunflowers",
    "departmentId": "",
    "maxResults": 25
}
````

To scrape by department with no keyword filter:

```json
{
    "q": "",
    "departmentId": "11",
    "maxResults": 100
}
```

To browse the full collection (first 50 objects):

```json
{}
```

### Output Example

```json
{
    "objectID": 436535,
    "title": "Wheat Field with Cypresses",
    "artist": "Vincent van Gogh",
    "artistNationality": "Dutch",
    "objectDate": "1889",
    "medium": "Oil on canvas",
    "department": "European Paintings",
    "classification": "Paintings",
    "culture": "",
    "isPublicDomain": true,
    "primaryImage": "https://images.metmuseum.org/CRDImages/ep/original/DT1567.jpg",
    "objectURL": "https://www.metmuseum.org/art/collection/search/436535",
    "accessionYear": "1993",
    "creditLine": "Purchase, The Annenberg Foundation Gift, 1993"
}
```

### Pricing

This Actor fetches data from the Metropolitan Museum of Art's free public API. Each run makes one search/list call plus one detail call per object.

- **Per result**: $0.003/result
- **Actor start**: Default platform rate
- **Typical run (50 results)**: ~$0.15 in Actor fees + minimal Apify compute costs
- **Typical run time**: Under 60 seconds for 50 results; under 5 minutes for 500 results

### Use Cases

- **Art history research** — Build datasets for academic analysis of styles, periods, or cultures
- **Education platforms** — Power art education apps with rich metadata and public-domain images
- **RAG pipeline content** — Feed artwork descriptions and provenance into LLM knowledge bases
- **Museum data aggregation** — Combine with other museum APIs for cross-collection research
- **Image dataset creation** — Collect public-domain images for computer vision training
- **Cultural analytics** — Analyze distribution of cultures, periods, and mediums across the collection

### Other Scrapers by SeatSignal

- [CISA KEV Scraper](https://apify.com/seatsignal/cisa-kev-scraper) — Extract CISA Known Exploited Vulnerabilities catalog data
- [Hotfrog Scraper](https://apify.com/seatsignal/hotfrog-scraper) — Extract business listings from Hotfrog directories
- [ConferenceIndex Scraper](https://apify.com/seatsignal/conferenceindex-scraper) — Extract academic and professional conference listings
- [CauseIQ Scraper](https://apify.com/seatsignal/causeiq-scraper) — Extract nonprofit organization data with EIN numbers

### FAQ

#### Is it legal to use the Metropolitan Museum of Art API?

Yes. The Met provides this API as a free public service under their [Open Access policy](https://www.metmuseum.org/about-the-met/policies-and-documents/open-access). Over 490,000 public-domain works are available for any use. No terms of service are violated by programmatic access to this official API.

#### Do I need an API key to use the Met Museum API?

No. The Metropolitan Museum of Art's collection API requires no authentication, API key, or account. This Actor accesses it directly without any credentials.

#### What is the `isPublicDomain` field?

When `isPublicDomain` is `true`, the Met has determined the artwork (and its images) are in the public domain and may be freely reproduced, modified, and distributed for any purpose including commercial use.

#### Can I export Met Museum data to Excel or CSV?

Yes. Apify supports exporting your results as JSON, CSV, Excel, XML, and other formats from the Dataset tab after a run completes.

#### Why are some `primaryImage` fields empty?

Not all Met objects have digitized images available. Objects that are not photographed, or whose images are rights-restricted, will have empty `primaryImage` fields.

#### How current is the data?

The Met Museum API reflects the live collection database. New acquisitions and updates appear in real time. Schedule this Actor to run periodically to keep your dataset current.

### Legal Disclaimer

This Actor accesses publicly available data from the Metropolitan Museum of Art's official open-access collection API (collectionapi.metmuseum.org). No authentication bypass, scraping of protected content, or violation of terms of service is involved. The Met explicitly encourages programmatic access to this API for research and educational purposes. Users are responsible for ensuring their downstream use of the extracted data complies with applicable laws and the Met's open access policy. For support, contact the Actor developer through the Apify Store.

# Actor input Schema

## `q` (type: `string`):

Keyword search query for the collection (e.g., 'sunflowers', 'portrait', 'ancient egypt'). Leave blank to browse all objects.

## `departmentId` (type: `string`):

Filter by museum department ID (integer). Examples: 1=American Decorative Arts, 3=Ancient Near Eastern Art, 5=Arts of Africa, 6=Asian Art, 9=Drawings & Prints, 11=European Paintings, 21=Modern Art. Leave blank to search all departments.

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

Maximum number of artwork records to return. Min 1, max 1000.

## Actor input object example

```json
{
  "q": "",
  "departmentId": "",
  "maxResults": 50
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/met-museum-collection-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/met-museum-collection-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 '{}' |
apify call compute-edge/met-museum-collection-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Met Museum Collection Scraper — Art, Artists & Images",
        "description": "Extract artworks from the Metropolitan Museum of Art Collection API. Get title, artist, date, medium, department, classification, culture, public-domain status, images, and credit lines. Search by keyword or department. Clean JSON for art research and catalogs.",
        "version": "0.1",
        "x-build-id": "uZ0MAYJ6F0nLhvddk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~met-museum-collection-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-met-museum-collection-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/compute-edge~met-museum-collection-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-met-museum-collection-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/compute-edge~met-museum-collection-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-met-museum-collection-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",
                "properties": {
                    "q": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword search query for the collection (e.g., 'sunflowers', 'portrait', 'ancient egypt'). Leave blank to browse all objects.",
                        "default": ""
                    },
                    "departmentId": {
                        "title": "Department ID",
                        "type": "string",
                        "description": "Filter by museum department ID (integer). Examples: 1=American Decorative Arts, 3=Ancient Near Eastern Art, 5=Arts of Africa, 6=Asian Art, 9=Drawings & Prints, 11=European Paintings, 21=Modern Art. Leave blank to search all departments.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of artwork records to return. Min 1, max 1000.",
                        "default": 50
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
