# Open Culture MCP Server: Art and Archives (`mrbridge/open-culture-mcp`) Actor

Find museum art, Creative Commons images and sounds, library archives and prize winners from Claude or ChatGPT. 16 read-only MCP tools give each result's license and link museum images of public-domain works only. Made using Openverse, but not endorsed or certified by Openverse.

- **URL**: https://apify.com/mrbridge/open-culture-mcp.md
- **Developed by:** [MrBridge](https://apify.com/mrbridge) (community)
- **Categories:** MCP servers, AI, Education
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 read operations

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/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

## Open Culture MCP Server: Art and Archives

Open Culture MCP Server gives Claude, ChatGPT, Cursor and any other MCP client 16 read-only tools over five open cultural sources: the collections of The Metropolitan Museum of Art and the Art Institute of Chicago, openly licensed images and sounds indexed by Openverse, the digital collections of the Library of Congress, and laureate records from the Nobel Prize API. No source key is needed, only your Apify token.

Ask Claude for public-domain paintings of water lilies with images you can reuse. It calls `art_search_artworks`, which queries both museums at once and returns up to five works from each, with the artist, the date, a public-domain flag and, for public-domain works only, the image link the museum publishes. Works still under copyright stay in the list with their rights line and no image.

**Made using Openverse, but not endorsed or certified by Openverse.** This server is not affiliated with or endorsed by any of the institutions it reads.

### What this server exposes

This server gives an AI assistant read-only access to five open cultural sources through 16 tools: the collection of The Metropolitan Museum of Art, the collection of the Art Institute of Chicago, openly licensed images and sounds indexed by Openverse, the digital collections of the Library of Congress, and the Nobel Prize records. It searches artworks in both museums at once, opens full museum records with public-domain image links, finds Creative Commons media with their licence and credit line, returns the rights statement of a library item, and lists Nobel laureates and prizes with their motivations. The ChatGPT `search` and `fetch` pair covers the two museums. Every source is public and keyless, so you need no credential beyond your Apify token, and every answer names its sources and licences.

### Tools

| Tool | What it answers | Billed event |
|---|---|---|
| `art_search_artworks` | Search artworks across museums | `tool-action` |
| `art_search_met_collection` | Search The Met collection | `tool-action` |
| `art_get_met_object` | Get a Met object record | `tool-read` |
| `art_list_met_departments` | List The Met departments | `tool-read` |
| `art_search_aic_artworks` | Search the Art Institute of Chicago | `tool-read` |
| `art_get_aic_artwork` | Get an Art Institute of Chicago artwork | `tool-read` |
| `art_search_open_media` | Search openly licensed images and audio | `tool-read` |
| `art_get_open_media` | Get an openly licensed image or sound | `tool-read` |
| `art_search_loc_items` | Search Library of Congress digital collections | `tool-read` |
| `art_get_loc_item` | Get a Library of Congress item | `tool-read` |
| `art_search_loc_collections` | Find Library of Congress digital collections | `tool-read` |
| `art_search_nobel_laureates` | Search Nobel Prize laureates | `tool-read` |
| `art_get_nobel_laureate` | Get a Nobel Prize laureate | `tool-read` |
| `art_list_nobel_prizes` | List Nobel Prizes | `tool-read` |
| `search` | Search | `tool-read` |
| `fetch` | Fetch | `tool-read` |

#### `art_search_artworks`: Search artworks across museums

Use this when you need artworks on a subject, by an artist or in a style from major museum collections, The Metropolitan Museum of Art and the Art Institute of Chicago at once, for example public-domain paintings of water lilies with reusable images. Do not use for museum-specific filters or deeper pages (art_search_met_collection, art_search_aic_artworks), for one full record (art_get_met_object, art_get_aic_artwork) or for openly licensed photos and sounds (art_search_open_media). Parameters: `query` (text, e.g. "water lilies"), `museums` (list of "met" and "aic", default both), `public_domain_only` (default false, true keeps works marked public domain), `per_museum` (1 to 10 results from each museum, default 5), `response_format` ("concise" or "detailed" to add place, dimensions, credit line, department and more image links). Each row names its museum, says whether the work is public domain and gives an image link only for public-domain works (`image_use`). Results alternate between museums.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | yes | `"water lilies"` |
| `museums` | array of string | no | `["met","aic"]` |
| `public_domain_only` | boolean | no | `true` |
| `per_museum` | integer | no | `5` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ query, museums[], public_domain_only, results[], totals, failed_sources[], next_steps[], omitted, attribution }`. Upstream: The Met, Art Institute of Chicago. Cache: daily (1 day). Read-only.

#### `art_search_met_collection`: Search The Met collection

Use this when you need works from The Metropolitan Museum of Art with Met-specific filters: department, highlights, works on view, medium, place, date range, or when you need further pages of results. Do not use for a search across several museums (art_search_artworks), for one full record (art_get_met_object) or for the Art Institute of Chicago (art_search_aic_artworks). Parameters: `query` (text, e.g. "hanging scroll"), `search_in` ("all" default, "title", "tags" or "artist_or_culture"), `department_id` (from art_list_met_departments, e.g. 6 for Asian Art), `highlights_only`, `on_view_only`, `has_images`, `public_domain_only` (booleans, default false), `medium` (e.g. "Paintings", several joined by |), `geo_location` (e.g. "Japan"), `date_begin` and `date_end` (years, both together, negative for BC, e.g. 1615 and 1868), `limit` (1 to 20, default 10, at most 10 in detailed mode), `offset`, `response_format`. Give a query or at least one filter. Image links are given only for public-domain works. With public_domain_only, other works of the page are left out and counted in `omitted`, so a page can hold fewer rows.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | no | `"hanging scroll"` |
| `search_in` | "all" or "title" or "tags" or "artist_or_culture" | no | `"all"` |
| `department_id` | integer | no | `6` |
| `highlights_only` | boolean | no | `false` |
| `on_view_only` | boolean | no | `false` |
| `has_images` | boolean | no | `true` |
| `public_domain_only` | boolean | no | `false` |
| `medium` | string | no | `"Paintings"` |
| `geo_location` | string | no | `"Japan"` |
| `date_begin` | integer | no | `1615` |
| `date_end` | integer | no | `1868` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ query, artworks[], pagination, next_steps[], omitted, attribution }`. Upstream: The Met. Cache: daily (1 day). Read-only.

#### `art_get_met_object`: Get a Met object record

Use this when you need the full record of one object of The Metropolitan Museum of Art: artist and life dates, date, medium, dimensions, culture and period, place, credit line, rights line, tags, image links and linked-data identifiers. Do not use for searching (art_search_artworks, art_search_met_collection) or for Art Institute of Chicago artworks (art_get_aic_artwork). Parameter: `object_id` (number, "met-45734" or a metmuseum.org object URL, e.g. 45734). Image links (primary, full size and additional views) are given only when The Met marks the work as public domain. Otherwise the rights line is kept and no image link is returned.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `object_id` | value | yes | `45734` |

Returns `{ artwork, met, attribution }`. Upstream: The Met. Cache: daily (1 day). Read-only.

#### `art_list_met_departments`: List The Met departments

Use this when you need the curatorial departments of The Metropolitan Museum of Art and their ids, to filter art_search_met_collection by department_id, for example Asian Art or European Paintings. Do not use for artworks themselves (art_search_met_collection, art_search_artworks). No parameters. Returns every department with its id and name (about 19).

No parameters.

Returns `{ departments[], count, attribution }`. Upstream: The Met. Cache: reference (30 days). Read-only.

#### `art_search_aic_artworks`: Search the Art Institute of Chicago

Use this when you need works from the Art Institute of Chicago with its filters: public domain only, works on view, artwork type, creation years, or when you need further pages of results. Do not use for a search across several museums (art_search_artworks), for one full record with the curator description (art_get_aic_artwork) or for The Met (art_search_met_collection). Parameters: `query` (text, e.g. "impressionism"), `public_domain_only` and `on_view_only` (booleans, default false), `artwork_type` (exact type name, e.g. "Painting", "Print", "Photograph", "Sculpture", "Textile"), `date_from` and `date_to` (creation years, negative for BC, e.g. 1860 and 1900), `limit` (1 to 20, default 10, at most 10 in detailed mode), `offset` (the first 10,000 results are reachable), `response_format`. Image links (IIIF) are given only for public-domain works.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | no | `"impressionism"` |
| `public_domain_only` | boolean | no | `true` |
| `on_view_only` | boolean | no | `false` |
| `artwork_type` | string | no | `"Painting"` |
| `date_from` | integer | no | `1860` |
| `date_to` | integer | no | `1900` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ query, artworks[], pagination, next_steps[], attribution }`. Upstream: Art Institute of Chicago. Cache: daily (1 day). Read-only.

#### `art_get_aic_artwork`: Get an Art Institute of Chicago artwork

Use this when you need the full record of one Art Institute of Chicago artwork: artist, date, medium, dimensions, credit line, copyright notice, curator description, provenance, exhibition history, and IIIF image links. Do not use for searching (art_search_artworks, art_search_aic_artworks) or for The Met (art_get_met_object). Parameter: `artwork_id` (number, "aic-27992" or an artic.edu artwork URL, e.g. 27992). Image links are given only for public-domain works, with the IIIF base to request other sizes. The description text is licensed CC BY 4.0 and comes with its credit line. Long texts are shortened and listed in `truncated_fields`.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `artwork_id` | value | yes | `27992` |

Returns `{ artwork, texts, attribution }`. Upstream: Art Institute of Chicago. Cache: daily (1 day). Read-only.

#### `art_search_open_media`: Search openly licensed images and audio

Use this when you need openly licensed images or sounds (Creative Commons, public domain) from Openverse, with each item's licence, creator and ready-made attribution text, for example photos of vineyards you may use commercially. Do not use for museum collection records (art_search_artworks) or library collections (art_search_loc_items). Parameters: `query` (text, at most 200 characters, e.g. "vineyard"), `media_type` ("image" default or "audio"), `licences` (list of codes: by, by-sa, by-nd, by-nc, by-nc-sa, by-nc-nd, cc0, pdm, sampling+, nc-sampling+), `commercial_use_only` and `modification_allowed_only` (booleans, default false), `category` (image: digitized_artwork, illustration, photograph. audio: audiobook, music, news, podcast, pronunciation, sound_effect), `source` (a collection such as "wikimedia" or "flickr"), `limit` (1 to 20, default 10), `offset` (below 400, the anonymous depth), `response_format` ("detailed" adds size, duration, tags and file type). Openverse limits anonymous use to about 100 calls a day on this server, so answers are cached for a day. A page stops at each block of 20 results, follow `next_offset`.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | yes | `"vineyard"` |
| `media_type` | "image" or "audio" | no | `"image"` |
| `licences` | array of string | no | `["cc0","pdm","by"]` |
| `commercial_use_only` | boolean | no | `true` |
| `modification_allowed_only` | boolean | no | `false` |
| `category` | string | no | `"photograph"` |
| `source` | string | no | `"wikimedia"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ query, media_type, items[], pagination, next_steps[], omitted, attribution }`. Upstream: Openverse. Cache: daily (1 day). Read-only.

#### `art_get_open_media`: Get an openly licensed image or sound

Use this when you need the licence, creator, attribution text, file and landing links, size or duration and tags of one Openverse image or sound, for example to credit it correctly. Do not use for searching (art_search_open_media) or for museum records (art_get_met_object, art_get_aic_artwork). Parameters: `media_id` (Openverse UUID or an openverse.org link, e.g. "32657d2b-a3f6-4e39-9fc2-5bbb5201da9c"), `media_type` ("image" default or "audio", read from the link when it names one).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `media_id` | string | yes | `"32657d2b-a3f6-4e39-9fc2-5bbb5201da9c"` |
| `media_type` | "image" or "audio" | no | `"image"` |

Returns `{ item, attribution }`. Upstream: Openverse. Cache: daily (1 day). Read-only.

#### `art_search_loc_items`: Search Library of Congress digital collections

Use this when you need digitized items from the Library of Congress: photos, prints, maps, manuscripts, sound recordings, films, sheet music, newspapers, books or web archives, on a subject, place or period, for example Dust Bowl photos from the 1930s. Do not use for museum artworks (art_search_artworks), for openly licensed stock media (art_search_open_media) or for the rights of one item (art_get_loc_item). Parameters: `query` (text, e.g. "dust bowl", needed unless `format` or `collection` is set), `format` ("any" default, "photos", "maps", "manuscripts", "audio", "film-and-videos", "books", "newspapers", "notated-music", "web-archives"), `collection` (a collection slug from art_search_loc_collections, e.g. "civil-war-maps", with format "any"), `date_from` and `date_to` (years, e.g. 1930 and 1939), `sort` ("relevance" default, "date", "date_desc", "title"), `limit` (1 to 25, default 10), `offset`, `response_format` ("detailed" adds subjects, places, languages, collections and a summary). Search results carry no rights statement: each row gives the item_id to pass to art_get_loc_item. The Library allows few requests per minute, so answers can take a few seconds.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | no | `"dust bowl"` |
| `format` | "any" or "photos" or "maps" or "manuscripts" or "audio" or "film-and-videos" or "books" or "newspapers" or "notated-music" or "web-archives" | no | `"photos"` |
| `collection` | string | no | `"civil-war-maps"` |
| `date_from` | integer | no | `1930` |
| `date_to` | integer | no | `1939` |
| `sort` | "relevance" or "date" or "date_desc" or "title" | no | `"relevance"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ query, format, collection, items[], pagination, next_steps[], attribution }`. Upstream: Library of Congress. Cache: daily (1 day). Read-only.

#### `art_get_loc_item`: Get a Library of Congress item

Use this when you need one Library of Congress item in full: its rights and access statements, description, contributors, subjects, dates, formats, image and file links, and a suggested citation, for example before reusing a photo. Do not use for searching (art_search_loc_items) or for museum artworks (art_get_met_object, art_get_aic_artwork). Parameter: `item_id` (an item id from art_search_loc_items, e.g. "2017762891", or a loc.gov item URL such as https://www.loc.gov/item/2017762891/). Rights vary item by item: read `rights` (kept whole) before reuse. Image links are returned as published, never as a statement that the image is free to use. Long summaries and notes are shortened and listed in `truncated_fields`. The citation is the Library's experimental suggestion.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `item_id` | string | yes | `"2017762891"` |

Returns `{ item, attribution }`. Upstream: Library of Congress. Cache: daily (1 day). Read-only.

#### `art_search_loc_collections`: Find Library of Congress digital collections

Use this when you need the Library of Congress digital collections on a theme, with their slugs, for example the collections about jazz or the Civil War, to then search inside one. Do not use for single items (art_search_loc_items, art_get_loc_item). Parameters: `query` (text, e.g. "jazz", optional to list every collection), `limit` (1 to 25, default 10), `offset`, `response_format` ("detailed" adds dates, subjects, a picture link and a longer summary). Pass a row's `slug` as `collection` to art_search_loc_items to search inside it.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | no | `"jazz"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ query, collections[], pagination, next_steps[], attribution }`. Upstream: Library of Congress. Cache: daily (1 day). Read-only.

#### `art_search_nobel_laureates`: Search Nobel Prize laureates

Use this when you need Nobel Prize laureates matching a name, a category, a period, a gender, a birth country or continent, an affiliation or words of the motivation, for example physics laureates from 2000 to 2010 or women laureates in literature. Do not use for the list of prizes of a year with every laureate (art_list_nobel_prizes) or for one laureate in full (art_get_nobel_laureate). Parameters: `name` (e.g. "Curie"), `category` (physics, chemistry, medicine, literature, peace, economics or their codes), `year_from` and `year_to` (award years from 1901, the same value for one year), `gender` ("female", "male" or "other"), `birth_country` (e.g. "France"), `birth_continent` (e.g. "Europe"), `affiliation` (e.g. "Stanford University"), `motivation_contains` (e.g. "neural networks"), `sort` ("asc" or "desc" by name), `limit` (1 to 25, default 10, at most 15 in detailed mode), `offset`, `response_format` ("detailed" adds affiliations, residences, amounts and Wikidata). Each laureate comes with its prizes and motivations as published, and a link to its nobelprize.org page.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `name` | string | no | `"Curie"` |
| `category` | string | no | `"physics"` |
| `year_from` | integer | no | `2000` |
| `year_to` | integer | no | `2010` |
| `gender` | "female" or "male" or "other" | no | `"female"` |
| `birth_country` | string | no | `"France"` |
| `birth_continent` | "Africa" or "Asia" or "Europe" or "North America" or "Oceania" or "South America" or "Antarctica" | no | `"Europe"` |
| `affiliation` | string | no | `"Stanford University"` |
| `motivation_contains` | string | no | `"neural networks"` |
| `sort` | "asc" or "desc" | no | `"asc"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ laureates[], pagination, next_steps[], attribution }`. Upstream: Nobel Prize API. Cache: daily (1 day). Read-only.

#### `art_get_nobel_laureate`: Get a Nobel Prize laureate

Use this when you need one Nobel Prize laureate in full: every prize with year, category, motivation, share and status, affiliations and residences at the time of the award, prize amounts, birth and death, and Wikipedia and Wikidata links. Do not use for finding laureates (art_search_nobel_laureates) or for the prizes of a year (art_list_nobel_prizes). Parameter: `laureate_id` (number from the search tools, or "nobel-745", e.g. 745).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `laureate_id` | value | yes | `745` |

Returns `{ laureate, attribution }`. Upstream: Nobel Prize API. Cache: daily (1 day). Read-only.

#### `art_list_nobel_prizes`: List Nobel Prizes

Use this when you need the Nobel Prizes of a year, a period or a category with their laureates and motivations, for example every prize of 2025 or the peace prizes since 1990. Do not use for searching laureates by name, country or gender (art_search_nobel_laureates) or for one laureate in full (art_get_nobel_laureate). Parameters: `year_from` and `year_to` (award years from 1901, the same value for one year, e.g. 2025 and 2025), `category` (physics, chemistry, medicine, literature, peace, economics or their codes), `sort` ("desc" default, newest first, or "asc"), `limit` (1 to 25, default 10), `offset`, `response_format` ("detailed" adds the award date, the prize amounts in SEK and the full category name). A year without a prize in a category is returned with `awarded` false and the published note in `top_motivation` when there is one.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `year_from` | integer | no | `2025` |
| `year_to` | integer | no | `2025` |
| `category` | string | no | `"physics"` |
| `sort` | "asc" or "desc" | no | `"desc"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ prizes[], pagination, next_steps[], attribution }`. Upstream: Nobel Prize API. Cache: daily (1 day). Read-only.

#### `search`: Search

Use this when ChatGPT needs to find artworks in The Metropolitan Museum of Art and the Art Institute of Chicago by subject, title, artist or style. Do not use for other sources, the prefixed art\_ tools cover openly licensed media, the Library of Congress and the Nobel Prize. Parameter `query` (string), e.g. "water lilies". Returns up to 10 results with ids such as "met-45734" and "aic-27992".

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | yes | `"water lilies"` |

Returns `{ results[], notices[] }`. Upstream: The Met, Art Institute of Chicago. Cache: daily (1 day). Read-only.

#### `fetch`: Fetch

Use this when ChatGPT needs the full record of one artwork returned by search, as text: artist, date, medium, dimensions, credit line, rights, and the image link when the work is public domain. Do not use for ids that did not come from search. Parameter `id` (from search), e.g. "met-45734" or "aic-27992".

| Parameter | Type | Required | Example |
|---|---|---|---|
| `id` | string | yes | `"met-45734"` |

Returns `{ id, title, text, url, metadata, notices[] }`. Upstream: The Met, Art Institute of Chicago. Cache: daily (1 day). Read-only.

### Connect

Endpoint (Streamable HTTP): `https://mrbridge--open-culture-mcp.apify.actor/mcp`

Every client authenticates with your Apify API token, found in [Apify Console > Settings > API & Integrations](https://console.apify.com/settings/integrations?fpr=mrbridge). Clients that support custom headers send it as `Authorization: Bearer <token>`. The others use the `?token=` URL variant, which must be treated as a secret: keep it out of commits, screenshots and shared logs.

#### Claude Code

```bash
claude mcp add --transport http open-culture "https://mrbridge--open-culture-mcp.apify.actor/mcp" --header "Authorization: Bearer ${APIFY_TOKEN}"
```

#### Cursor, VS Code and other JSON configurations

```json
{
  "mcpServers": {
    "open-culture": {
      "type": "http",
      "url": "https://mrbridge--open-culture-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer ${APIFY_TOKEN}"
      }
    }
  }
}
```

#### claude.ai and Claude Desktop

Add a custom connector with the URL `https://mrbridge--open-culture-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN` and no authentication. Prefilled link (replace the token placeholder before saving): [add Open Culture MCP Server: Art and Archives to Claude](https://claude.ai/customize/connectors?modal=add-custom-connector\&connectorName=Open%20Culture%20MCP%20Server%3A%20Art%20and%20Archives\&connectorUrl=https%3A%2F%2Fmrbridge--open-culture-mcp.apify.actor%2Fmcp%3Ftoken%3DYOUR_APIFY_TOKEN).

#### ChatGPT (developer mode)

Settings > Apps > Create, URL `https://mrbridge--open-culture-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN`, authentication "No authentication". ChatGPT snapshots the tool list: after a server update, an admin has to click Refresh on the app.

#### OpenAI Responses API

```json
{
  "type": "mcp",
  "server_label": "open_culture",
  "server_url": "https://mrbridge--open-culture-mcp.apify.actor/mcp",
  "headers": {
    "Authorization": "Bearer YOUR_APIFY_TOKEN"
  },
  "require_approval": "never"
}
```

Add `allowed_tools` to restrict the tool list. Tool calls must finish within about 60 seconds on this API, and every tool of this server answers in under 50 seconds.

#### Anthropic Messages API

```json
{
  "mcp_servers": [
    {
      "type": "url",
      "url": "https://mrbridge--open-culture-mcp.apify.actor/mcp",
      "name": "open-culture",
      "authorization_token": "YOUR_APIFY_TOKEN"
    }
  ],
  "tools": [
    {
      "type": "mcp_toolset",
      "mcp_server_name": "open-culture"
    }
  ]
}
```

Send the beta header `anthropic-beta: mcp-client-2025-11-20`.

#### One-click OAuth alternative

`https://mcp.apify.com/?tools=mrbridge/open-culture-mcp` connects through Apify OAuth without a token. It exposes the Actor as a single tool rather than the granular tools listed above.

#### Cost control

Each Standby run has a spending limit (`maxTotalChargeUsd`). When a call uses the last of it, the result is still returned, and later calls in that run answer `CHARGE_LIMIT_REACHED` until the limit is raised.

### Why use Open Culture MCP Server

Museum APIs, image search engines and library catalogues all answer in their own format, and each has its own idea of what you may reuse. This server puts five of them behind one set of tools and keeps the licence in view at every step.

- **One artwork search, two museums.** `art_search_artworks` reads The Met and the Art Institute of Chicago in a single call and gives every result the same row, museum named and public-domain flag included. If one museum is down, the other still answers and the missing one is listed in `failed_sources`.
- **Museum image links only where reuse is clear.** They come for works the museum marks as public domain, exactly as the museum publishes them. The server never hosts a copy.
- Openverse items arrive with their licence code, the creator, two flags (`commercial_use_allowed`, `modification_allowed`) and an attribution text you can paste under the picture. Library of Congress items keep their rights statement whole.
- **ChatGPT deep research works too.** The `search` and `fetch` pair lets ChatGPT search both museums and cite one record as text.

It is also gentle on the sources. Openverse and the Library of Congress allow few anonymous calls, so the server paces its calls, caches answers for a day and pauses after a rate-limit answer. On a busy day that means a call can answer `UPSTREAM_RATE_LIMITED`, which is never charged.

### Pricing (Pay-per-Event)

| Event | Charged when | Price |
|---|---|---|
| `apify-actor-start` | run start (platform default) | see the Store page |
| `tool-read` (primary event) | each successful read tool call | see the Store page |
| `tool-action` | each successful call of a detailed or computed tool | see the Store page |

Never charged: initialize, tools/list, pings, readiness probes, and any call that ends in an error (invalid input, not found, upstream failure, timeout, spending limit).

Platform usage comes on top of these events. This server runs in Apify Standby mode, and you also pay the platform usage of your own Standby run, billed to your Apify account like any other run: the memory set for the Standby run, for as long as the server is up, idle time included, until the run stops at its idle timeout.
The [Apify pay-per-event documentation](https://docs.apify.com/actors/publishing/monetize/pay-per-event#platform-usage-costs) says so: "For runs in Standby mode, users always pay the platform usage costs in addition to the event charges."

### Limits, caveats and attribution

- **Attribution.** Each answer carries an `attribution` block with the sources used, their licence, their terms page and the notices they require. Keep it with the data when you pass it on.
- **Museum images.** The Met and the Art Institute of Chicago publish images for works they mark as public domain. This server returns image links for those works only, as the museums publish them, and never hosts a copy. Other works come without an image link, with `image_use: "not_provided"` and their rights line or copyright notice. Museum data is CC0, except the curator description of the Art Institute of Chicago, which is licensed CC BY 4.0 and comes with its credit line.
- **The Met.** Each search result costs one extra call to read the object record, so a page holds at most 20 results (10 in detailed mode). Search rows keep texts to 300 characters, the record tools give them in full. With `public_domain_only`, works that are not public domain are left out after that call, and a page can hold fewer rows than asked. Search reaches the first 10,000 results of a query.
- **Art Institute of Chicago.** The museum throttles anonymous clients to 60 requests per minute, and search reaches the first 10,000 results. `artwork_type` is an exact, case-sensitive name such as "Painting".
- **Openverse.** Anonymous access is limited to about 20 requests per minute and 200 per day, and this server keeps to half of that. Answers are cached for a day, a search reaches its first 400 results, and after a rate-limit answer the server pauses its Openverse calls for 15 minutes. A spent daily quota answers `UPSTREAM_RATE_LIMITED` until the next day. Items are works hosted by third parties under their own licence: check the licence on the work's own page before reuse. Sensitive content is never requested and is left out when it appears.
- **Library of Congress.** The Library asks for no more than 10 requests per minute and blocks a client for an hour past its limit. This server keeps to 5 per minute, caches for a day, and pauses its calls for an hour after a rate-limit or block answer, so a busy period can answer `UPSTREAM_RATE_LIMITED` or `UPSTREAM_BLOCKED` with the time calls resume. Rights vary item by item: search rows point to `art_get_loc_item`, which returns the rights and access statements. The Library generally does not own the rights to its collections.
- **Nobel Prize.** Data is served as published by the Nobel Prize API, including partial dates such as "1943-00-00". No portrait or medal image is provided. Prize data for the current year is cached for an hour, older years for a day.
- **Freshness.** Museum, Openverse and Library of Congress answers can be up to a day old, and a source that is down can be answered from an older copy, marked `stale` in the `cache` block.

### Data terms

By using this server you agree to use what it returns in line with the terms of each source, and to pass the same obligations on to anyone you share it with.

- The Met: [Terms and conditions](https://www.metmuseum.org/policies/terms-and-conditions). Open Access data and public-domain images are CC0. Works outside Open Access are for noncommercial, educational or personal use only. Do not use The Met's names or logos, in a URL or elsewhere, or suggest its endorsement.
- Art Institute of Chicago: [Terms](https://www.artic.edu/terms) and [API documentation](https://api.artic.edu/docs/#copyright). Data and public-domain images are CC0. Credit the curator description as "Art Institute of Chicago, CC BY 4.0". Do not reproduce the museum's logo, lion statues or building image.
- Openverse: [Terms of service](https://docs.openverse.org/terms_of_service.html). Credit each work with its attribution text, follow its licence and the terms of the site that hosts it. This server was made using Openverse, but is not endorsed or certified by Openverse.
- Library of Congress: [Legal overview](https://www.loc.gov/legal/). Determine whether an item is protected before you publish or distribute it, and respect privacy and publicity rights.
- Nobel Prize: [Terms of use for the API](https://www.nobelprize.org/about/terms-of-use-for-api-nobelprize-org-and-data-nobelprize-org/). The data is CC0. Do not alter it to mislead, and do not use the Nobel Prize names, medal or logos in your own product names or in a way that suggests endorsement.

The fee for this server pays for the service (hosting, caching, normalisation), not for a licence on the data or on any work it points to.

### Use cases

**Illustrating a lesson or an article.** A teacher preparing a session on Impressionism asks for paintings from both museums. Public-domain works come with image links she can put on her slides, and the others are flagged as still under copyright.

**Finding a photo you may use commercially.** "Photos of vineyards I can use commercially" becomes a call to `art_search_open_media` with `commercial_use_only` set. Each result arrives with the attribution text to copy under the picture. Check the licence on the work's own page before you publish.

**Archive work on a period.** Search Library of Congress photos of the Dust Bowl between 1930 and 1939, then open one item with `art_get_loc_item` to read its rights and access statements before any reuse.

**Prize history for a quiz or a talk.** "Which women won the Nobel Prize in Literature?" and "Who won in physics between 2000 and 2010?" both come back with the motivations as published.

**Browsing a museum department.** Japanese hanging scrolls of the Edo period (1615 to 1868) at The Met, filtered on the Asian Art department and on works currently on view.

### Frequently asked questions

#### How much does a call cost?

You pay per event. Each tool call that succeeds is one `tool-read` event at $0.005, or one `tool-action` event at $0.01 for `art_search_artworks` and `art_search_met_collection`, which read every Met record they return, and Apify charges its `apify-actor-start` event when your Standby run starts. As an example, 100 successful read calls come to $0.50 in `tool-read` events, plus the start event: that figure covers the events only. These are the FREE plan prices: Apify plan discounts lower them, and the Pricing tab shows the price on your plan.

On top of the events, Apify bills the platform usage of your own Standby run to your account, at the rates of your plan: the memory set for the run (256 MB by default) for as long as the server is up, idle time included, until it stops at its idle timeout (about 5 minutes without a call by default). Errors, invalid input, timeouts, `initialize`, `tools/list` and pings are never charged as events. To cap what one run can spend on events, set `maxTotalChargeUsd`. The price table by Apify plan is on the [Pricing tab](https://apify.com/mrbridge/open-culture-mcp/pricing?fpr=mrbridge).

#### Can I reuse the images and data it returns?

It depends on the record, and every answer says which case applies. Museum data is CC0, except the Art Institute of Chicago curator description, which is CC BY 4.0 and comes with its credit line. Museum image links appear only for works the museum marks as public domain. Openverse items keep their own Creative Commons or public-domain licence (some are non-commercial), so read the licence and the terms of the site that hosts the work. Library of Congress rights vary from item to item. The fee pays for the service, not for a licence on any work.

#### What does the server not do?

It does not host, download or resize images, and it gives no museum image link for a work under copyright. There are no Nobel portraits or medal images. A search reaches the first 10,000 results in each museum and the first 400 on Openverse. Everything it reads is public: no private collection, no login.

#### Does it return personal data?

Laureate records carry the published prize facts and biography: names, gender as published, birth and death, affiliations and residences at the time of the award. Openverse items name their creator, because the licence asks for credit. No other source is joined to a person.

#### Why is a call slow or refused?

The first call after a quiet spell starts a new Standby run. In the platform test, that cold start took 4.6 seconds. Most later calls answered in a tenth of a second to about 2 seconds. Library of Congress calls are slower and paced at 5 per minute, and one collection search took 12.6 seconds. Openverse allows about 100 calls a day on this server, and a spent quota answers `UPSTREAM_RATE_LIMITED` until the next day. After a rate-limit answer, the server pauses its Library of Congress calls for an hour, or its Openverse calls for 15 minutes, and answers already in its cache still come back in the meantime. None of these error answers is charged.

#### Is it affiliated with the museums or the other sources?

No. The Metropolitan Museum of Art, the Art Institute of Chicago, Openverse, the Library of Congress and Nobel Prize Outreach are named as data sources only, and none of them endorses this server.

#### Your feedback

Found a wrong record, a missing filter or a bug? Open an issue on the [Issues tab](https://apify.com/mrbridge/open-culture-mcp/issues?fpr=mrbridge). More MCP servers, scrapers and data studies from the same team are on [mr-bridge.com](https://mr-bridge.com).

### Changelog

- 0.1.4: Output, dataset and key-value store schemas, as Apify asks for publication: the Output tab of a run started from the Console shows the connection details and one row per tool.
- 0.1.3: the Input tab shows the endpoint and how to connect an AI client, and a run started from the Console outputs the connection details and the tool list
- 0.1.2: pricing events tool-read and tool-action
- 0.1.1: server name aligned with the Store title (connector name and connection page). The endpoint and the tools do not change.
- 0.1.0: initial build (private, unpublished)

# Actor input Schema

## `mcpEndpoint` (type: `string`):

Paste this URL into your MCP client (Streamable HTTP). It is shown here for copying only: the server ignores this form, and every parameter goes in your questions.

## Actor input object example

```json
{
  "mcpEndpoint": "https://mrbridge--open-culture-mcp.apify.actor/mcp"
}
```

# Actor output Schema

## `connection` (type: `string`):

The item written by a run started from the Console: endpoint, token options, client recipes and the list of tools with the event each one bills.

# 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 = {
    "mcpEndpoint": "https://mrbridge--open-culture-mcp.apify.actor/mcp"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrbridge/open-culture-mcp").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 = { "mcpEndpoint": "https://mrbridge--open-culture-mcp.apify.actor/mcp" }

# Run the Actor and wait for it to finish
run = client.actor("mrbridge/open-culture-mcp").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 '{
  "mcpEndpoint": "https://mrbridge--open-culture-mcp.apify.actor/mcp"
}' |
apify call mrbridge/open-culture-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrbridge/open-culture-mcp"
        }
    }
}
```

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/XFoELzu4YVXe6CVqS/builds/wWBLs6WHqNlx8g9pg/openapi.json