# Artist Public Collection Finder (`trovevault/artist-public-collection-finder`) Actor

Find public collection records for artists with normalized institutions, creation dates, catalog details, links, images, rights statements, and evidence tiers.

- **URL**: https://apify.com/trovevault/artist-public-collection-finder.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** News, Travel, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.28 / 1,000 works

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Artist Public Collection Finder

Artist Public Collection Finder searches public cultural heritage records and museum catalogs for works by one or more named artists. It returns one normalized row per matched work, including the title, holding institution, country, creation date, medium, dimensions, acquisition details, public record URL, image URL, published rights statement, and evidence tier when available.

Use it when you need a structured starting point for artist research, curriculum planning, gallery research, collection benchmarking, or art market context. The Actor is designed for discovery across public records, not for claiming complete worldwide coverage.

### Why Use This Actor

- Find public collection records for one or more artists from one simple input: artist names.
- Discover which institutions visibly hold works by that artist.
- Export work-level records with museum links, dates, medium, dimensions, credit lines, and image availability.
- Build a quick institutional footprint summary with work count, institution count, country count, and medium breakdown.
- Prioritize detailed catalog records before using sparser public knowledge graph leads.
- Distinguish official, aggregated, legacy, and knowledge graph evidence with `evidenceTier`.
- Keep the dataset useful for researchers: one output item equals one interpreted public collection record.

### What It Produces

Each dataset row represents one public collection record for the requested artist:

- `artistName`
- `workTitle`
- `institution`
- `institutionCountry`
- `objectDate`, `objectBeginYear`, `objectEndYear`
- `medium`, `dimensions`, `department`
- `acquisitionYear`, `creditLine`
- `objectUrl`, `imageUrl`
- `rightsStatus`
- `evidenceTier`

The Actor also writes an `OUTPUT` key-value summary with:

- `matchedWorkCount`
- `institutionCount`
- `countryCount`
- `topInstitutions`
- `countryBreakdown`
- `mediumBreakdown`
- `evidenceBreakdown`
- `earliestWorkYear`
- `latestWorkYear`
- `researchSummary`
- `artistSummaries`

### Source Strategy

The Actor uses no browser automation. It prefers APIs and public datasets.

Current v1 coverage combines official museum APIs, public museum datasets, an optional European cultural index, and a public knowledge graph fallback. The Actor normalizes institution aliases, merges cross-source duplicates, ranks detailed catalog records first, and uses sparse knowledge graph records only after stronger catalog matches are exhausted.

`evidenceTier` explains how to interpret each row without exposing internal routing: `official_catalog`, `aggregated_catalog`, `legacy_catalog_snapshot`, or `knowledge_graph_lead`. The useful research link is `objectUrl`.

### Use Cases

- Art researchers checking where an artist appears in public collections
- Educators building reading lists, slides, or curriculum resources around artists and institutions
- Gallery teams preparing artist dossiers
- Collectors benchmarking an artist's institutional footprint
- Market researchers comparing public collection visibility across artists
- Museum professionals doing quick peer-collection discovery

### How To Use It

1. Enter one or more `artistNames`, for example `Louise Bourgeois` and `Leonardo da Vinci`.
2. Optionally set a creation year range in `dateFrom` and `dateTo`.
3. Optionally enable `onlyWorksWithImages` when image availability matters more than broad coverage.
4. Run the Actor and open the dataset.
5. Check `OUTPUT` for the summary.

### Input Example

```json
{
  "artistNames": ["Louise Bourgeois", "Leonardo da Vinci"],
  "maxResults": 50,
  "onlyWorksWithImages": false
}
````

Focused research example:

```json
{
  "artistNames": ["Louise Bourgeois"],
  "dateFrom": 1940,
  "dateTo": 2010,
  "onlyWorksWithImages": true,
  "maxResults": 100
}
```

Europeana enrichment is not exposed as a public input. If you want Europeana included in private runs, set `EUROPEANA_API_KEY` as an Actor environment variable.

### Input Reference

| Field | Type | Description |
|---|---:|---|
| `artistNames` | array | Required artist names to search. Use common catalog names. |
| `dateFrom` | integer | Optional earliest work creation year to include when a machine-readable year exists. |
| `dateTo` | integer | Optional latest work creation year to include when a machine-readable year exists. |
| `onlyWorksWithImages` | boolean | Return only rows with an image URL or thumbnail. |
| `maxResults` | integer | Maximum rows to write per artist, from 1 to 1000. |
| `datasetId` | string | Optional existing Apify dataset to append rows to. |
| `runId` | string | Optional workflow identifier copied into rows and summaries. |

### Output Example

```json
{
  "artistName": "Louise Bourgeois",
  "workTitle": "Eyes",
  "institution": "The Metropolitan Museum of Art",
  "institutionCountry": "United States",
  "objectDate": "1982",
  "objectBeginYear": 1982,
  "objectEndYear": 1982,
  "medium": "Marble",
  "dimensions": "74 3/4 x 54 x 45 3/4 in. (189.9 x 137.2 x 116.2 cm)",
  "department": "Modern and Contemporary Art",
  "acquisitionYear": "1986",
  "creditLine": "Anonymous Gift, 1986",
  "objectUrl": "https://www.metmuseum.org/art/collection/search/484544",
  "rightsStatus": "© Louise Bourgeois/Licensed by VAGA, New York, NY",
  "evidenceTier": "official_catalog"
}
```

### API Usage

```bash
curl "https://api.apify.com/v2/acts/trovevault~artist-public-collection-finder/runs?waitForFinish=120" \
  -X POST \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "artistNames": ["Louise Bourgeois", "Leonardo da Vinci"],
    "maxResults": 50,
    "onlyWorksWithImages": false
  }'
```

After the run finishes, export the default dataset as JSON, CSV, Excel, XML, or through the Apify API.

### Why This Instead Of Searching Museum Sites Manually

Museum collection search pages are useful, but they do not share one schema. This Actor normalizes public records into one table and adds a compact summary of the artist's visible public collection footprint. It is especially useful when you need to compare institutions, prepare a spreadsheet, or use collection records in downstream analysis.

### Limitations

- This is public-record discovery, not complete global coverage.
- Some museum collection records do not expose images, dimensions, acquisition details, or rights text. Empty values are omitted from JSON rows instead of being filled with `null`; the Actor never substitutes `unknown` as if it were a rights statement.
- Europeana requires an API key configured as `EUROPEANA_API_KEY` and focuses on European cultural heritage records.
- Knowledge graph leads may be incomplete or community-maintained. They are labeled `knowledge_graph_lead` and are selected only when stronger catalog records do not fill the requested result limit.
- Tate's open dataset is a historical snapshot and should be verified against the current Tate website for publication-grade work.
- Institution aliases are normalized only when the identity is known. Countries are taken from the record or resolved from a known normalized institution, not guessed from loose name fragments.
- `objectBeginYear` and `objectEndYear` describe the published creation range. A later casting or printing year mentioned in `objectDate` is not treated as the end of creation.
- Artist names can be ambiguous. Use the common museum catalog name and review the returned works.
- The Actor does not verify private collections, non-public inventory, loan status, or current display status.
- Exhibition history is not promised in v1 because it is not consistently available across sources.

### FAQ

#### Is this a worldwide museum database?

No. It is a global public collection discovery tool. It combines open global and regional indexes with selected official museum sources, then normalizes the results. It should not be marketed or used as a complete worldwide inventory.

#### Why are there fewer results than I see on a museum website?

Some museums expose more data on their website than in their public API or dataset. Some sources also apply licensing, image, copyright, or catalog restrictions.

#### Can I filter by museum?

Not in v1. The Actor owns source resolution so users can ask the natural research question: "Where does this artist appear in public collections?" Use the exported dataset to filter institutions afterward.

#### Can I use this for commercial art market research?

Yes, as public metadata research support, subject to each source's terms and rights notices. Rights for images and underlying works vary by record.

### Related Actors

Use this Actor alongside collection, artist, education, CRM, or market-research workflows when you need structured public collection evidence for an artist.

### Changelog

- `0.1` Initial artist-name lookup across public cultural heritage records, with catalog-first ranking, normalized institutions, evidence tiers, and quality-aware deduplication.

### Support

Open an Apify issue or contact TroveVault with the artist name, run ID, and an example record if a public collection result appears missing or mismatched.

# Actor input Schema

## `artistNames` (type: `array`):

One or more artist names to search across public collection data. Use common catalog names, for example `Louise Bourgeois`, `Leonardo da Vinci`, `Pablo Picasso`, or `Georgia O'Keeffe`.

## `dateFrom` (type: `integer`):

Earliest work creation year to include when a machine-readable year is available. Leave blank to include all available dates.

## `dateTo` (type: `integer`):

Latest work creation year to include when a machine-readable year is available. Leave blank to include all available dates.

## `onlyWorksWithImages` (type: `boolean`):

When enabled, only returns records with an image URL or thumbnail. Keep disabled for broader research coverage because many official records do not expose reusable images.

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

Maximum number of matching work rows to write for each artist. Use a smaller value for quick checks and a larger value for deeper research exports.

## `datasetId` (type: `string`):

ID of an existing Apify dataset to append results to, in addition to the default run dataset. Use this for research pipelines that combine many artist searches.

## `runId` (type: `string`):

Optional workflow identifier copied into output rows and summaries so downstream systems can trace this artist lookup.

## Actor input object example

```json
{
  "artistNames": [
    "Louise Bourgeois",
    "Leonardo da Vinci"
  ],
  "onlyWorksWithImages": false,
  "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 = {
    "artistNames": [
        "Louise Bourgeois",
        "Leonardo da Vinci"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/artist-public-collection-finder").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 = { "artistNames": [
        "Louise Bourgeois",
        "Leonardo da Vinci",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("trovevault/artist-public-collection-finder").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 '{
  "artistNames": [
    "Louise Bourgeois",
    "Leonardo da Vinci"
  ]
}' |
apify call trovevault/artist-public-collection-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trovevault/artist-public-collection-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Artist Public Collection Finder",
        "description": "Find public collection records for artists with normalized institutions, creation dates, catalog details, links, images, rights statements, and evidence tiers.",
        "version": "0.1",
        "x-build-id": "UqILNTDJeK9N2g05i"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~artist-public-collection-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-artist-public-collection-finder",
                "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/trovevault~artist-public-collection-finder/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-artist-public-collection-finder",
                "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/trovevault~artist-public-collection-finder/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-artist-public-collection-finder",
                "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": [
                    "artistNames"
                ],
                "properties": {
                    "artistNames": {
                        "title": "Artist Names",
                        "type": "array",
                        "description": "One or more artist names to search across public collection data. Use common catalog names, for example `Louise Bourgeois`, `Leonardo da Vinci`, `Pablo Picasso`, or `Georgia O'Keeffe`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dateFrom": {
                        "title": "Work Date From (optional)",
                        "type": "integer",
                        "description": "Earliest work creation year to include when a machine-readable year is available. Leave blank to include all available dates."
                    },
                    "dateTo": {
                        "title": "Work Date To (optional)",
                        "type": "integer",
                        "description": "Latest work creation year to include when a machine-readable year is available. Leave blank to include all available dates."
                    },
                    "onlyWorksWithImages": {
                        "title": "Only Works With Images",
                        "type": "boolean",
                        "description": "When enabled, only returns records with an image URL or thumbnail. Keep disabled for broader research coverage because many official records do not expose reusable images.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Maximum Results Per Artist",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of matching work rows to write for each artist. Use a smaller value for quick checks and a larger value for deeper research exports.",
                        "default": 50
                    },
                    "datasetId": {
                        "title": "Dataset ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify dataset to append results to, in addition to the default run dataset. Use this for research pipelines that combine many artist searches."
                    },
                    "runId": {
                        "title": "Run ID (optional)",
                        "type": "string",
                        "description": "Optional workflow identifier copied into output rows and summaries so downstream systems can trace this artist lookup."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```