# Art Institute of Chicago Scraper (`parseforge/art-institute-of-chicago-scraper`) Actor

Scrapes the Art Institute of Chicago's public collection. Returns each artwork as a flat row with title, artist, date, medium, image URL, and full metadata. Supports keyword search, department, classification, year range, public domain, and on-view filters.

- **URL**: https://apify.com/parseforge/art-institute-of-chicago-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Education, Business
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.75 / 1,000 result items

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

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

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

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

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Art Institute of Chicago Scraper

**Scrape the Art Institute of Chicago's public collection, up to a million artworks per run.** Every artwork comes with its title, artist, date, medium, image URL, and full metadata. No API key or login. Export to CSV, JSON, Excel, or XML.

The Art Institute of Chicago's official API requires an API key and rate limits you. This reads the public collection pages directly, filtered by department, classification, year range, public domain status, or on-view status, and returns each match in one fixed schema.

| Who uses it | What they scrape Art Institute of Chicago for |
|---|---|
| Art historians | Building a dataset of works by a specific artist or period for research |
| Data journalists | Analyzing the museum's collection for trends in acquisitions or representation |
| Educators | Creating a teaching set of public domain images for art history courses |
| App developers | Populating an art discovery app with museum metadata and image links |
| Collectors | Tracking which works by a favorite artist are currently on view |

### What it does

This Actor collects artworks from the Art Institute of Chicago's public collection by browsing all works or running a keyword search, and returns each one as a flat row.

- 🔍 **Keyword search:** find artworks by title, artist, or subject, like 'monet water lilies' or 'van gogh bedroom'.
- 🗂️ **Browse all artworks:** pull the entire collection in one run, up to a million records.
- 🏛️ **Department filter:** restrict to one curatorial department, from Arts of Africa to Modern and Contemporary Art.
- 🖼️ **Classification filter:** narrow to paintings, sculptures, prints, photographs, textiles, and more.
- 📅 **Year range filter:** limit results to artworks created within a specific time period.
- ✅ **Public domain only:** return only artworks marked as public domain, ideal for reuse.
- 👁️ **On view only:** return only artworks currently on display in a gallery.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Art Institute of Chicago data

**📚 Build a research dataset.**

An art historian runs a keyword search for 'impressionism' and filters by department to collect all relevant paintings with full metadata for a publication.

**📰 Analyze collection trends.**

A data journalist browses all artworks and filters by year range to chart the museum's acquisition patterns over decades.

**🎓 Create teaching materials.**

An educator enables public domain only and downloads a set of high-resolution image URLs for a course on 19th-century European painting.

**📱 Power an art app.**

A developer scrapes the full collection and uses the structured data to populate a mobile app with artwork details and images.

**🖼️ Plan a museum visit.**

A collector filters by on view only and a favorite artist to see which works are currently displayed before visiting.

### Why choose this scraper

|  | What you get |
|---|---|
| **No API key** | Scrape the public collection without registering for an API key or dealing with rate limits. |
| **Fixed schema** | Every artwork returns the same flat structure, ready for analysis or export. |
| **Large scale** | Pull up to a million artworks in a single run with a paid plan. |
| **Flexible filters** | Combine department, classification, year range, public domain, and on-view status. |

### How it compares

No other Store actor targets Art Institute of Chicago the same way, so the honest comparison is with the alternatives teams actually weigh.

| | Art Institute of Chicago Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When Art Institute of Chicago changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor from a keyword search or a full collection browse, and filters run as each artwork is read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10,
  "mode": "list"
}
```

A larger pull:

```json
{
  "maxItems": 200,
  "mode": "list"
}
```

### Pricing

Pay-per-result: **$0.005 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.50 |
| 1,000 results | $5.00 |
| 10,000 results | $50.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Art Institute of Chicago Scraper](https://apify.com/parseforge/art-institute-of-chicago-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Art Institute of Chicago through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/art-institute-of-chicago-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check your filters. If you set a department, classification, or year range that does not match any artworks, the result set will be empty. Try removing filters or broadening your search term.

**Why am I only getting 10 items?**

Free users are limited to 10 items as a preview. Upgrade to a paid plan to scrape up to 1,000,000 artworks.

**Why is my search term not returning expected artworks?**

The search matches the museum's own search index. Try different keywords, check spelling, or use a broader term. You can also switch to browse mode and filter by department or classification.

**Why are some image URLs missing?**

Some artworks may not have a public image URL. The Actor returns whatever image link is available on the collection page. If the field is empty, the museum may not provide an image for that work.

**Why does the run take a long time?**

Scraping a large number of artworks takes time. Reduce the maximum items or add filters to narrow the dataset. The Actor processes pages sequentially to avoid overloading the museum's servers.

### FAQ

| Question | Answer |
|---|---|
| Do I need an API key to use this scraper? | No. This Actor reads the Art Institute of Chicago's public collection pages directly, so no API key or login is required. |
| How many artworks can I scrape in one run? | Free users are limited to 10 items as a preview. Paid users can scrape up to 1,000,000 artworks per run. |
| Can I search for a specific artist or title? | Yes. Use the keyword search mode and enter a term like 'monet water lilies' or 'van gogh bedroom'. |
| What filters are available? | You can filter by department, classification, year range, public domain status, and whether the artwork is currently on view. |
| What data does each artwork include? | Each row includes the artwork's title, artist, date, medium, image URL, and full metadata from the museum's collection pages. |
| Can I export the data? | Yes. You can export the dataset to CSV, JSON, Excel, or XML. |
| Is the data from the official Art Institute of Chicago API? | No. This Actor scrapes the public collection pages directly, so it does not depend on the official API's rate limits or key requirements. |
| Can I scrape only public domain artworks? | Yes. Enable the 'Public domain only' checkbox to return only artworks marked as public domain. |
| Can I scrape only artworks currently on display? | Yes. Enable the 'On view only' checkbox to return only artworks currently on view in a gallery. |
| What is the difference between browse and search modes? | Browse mode pulls the full collection, while search mode runs a keyword query against the collection. Both support the same filters. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Art Institute of Chicago. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Browse the full collection or run a keyword search.

## `query` (type: `string`):

Free-text keyword for the search mode. Examples: 'monet water lilies', 'van gogh bedroom', 'sunset'.

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

Restrict to one curatorial department.

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

Restrict to one classification.

## `publicDomainOnly` (type: `boolean`):

When enabled, returns only artworks marked as public domain.

## `isOnView` (type: `boolean`):

When enabled, returns only artworks currently on view in a gallery.

## Actor input object example

```json
{
  "maxItems": 10,
  "mode": "list",
  "publicDomainOnly": false,
  "isOnView": false
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 10,
    "mode": "list",
    "departmentId": "",
    "classification": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/art-institute-of-chicago-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 = {
    "maxItems": 10,
    "mode": "list",
    "departmentId": "",
    "classification": "",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/art-institute-of-chicago-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "mode": "list",
  "departmentId": "",
  "classification": ""
}' |
apify call parseforge/art-institute-of-chicago-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/art-institute-of-chicago-scraper"
        }
    }
}
```

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/pm1wsxvh2J7nBU7c3/builds/9rX0SBNXX02seKh5n/openapi.json