# Artmajeur.com Artist & Artwork Scraper (`artsiom_k/artmajeur-scraper`) Actor

Artmajeur.com artist & artwork scraper with real per-artist rollup stats (avg price, medium mix, sold count) from each artist's full catalog, plus delta mode.

- **URL**: https://apify.com/artsiom\_k/artmajeur-scraper.md
- **Developed by:** [Artsiom Kunitsyn](https://apify.com/artsiom_k) (community)
- **Categories:** Other, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are 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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## artmajeur-scraper

Scrapes both **artworks** and **artist profiles** from [Artmajeur.com](https://www.artmajeur.com),
including per-artist rollup stats (average price, medium mix, sold count, latest artwork) computed
from the artist's full catalog — not a sample.

### Contents

- [Key features](#key-features)
- [Output](#output)
- [Input](#input)
- [Input examples](#input-examples)
- [Incremental (delta) mode](#incremental-delta-mode)
- [How to scrape Artmajeur.com](#how-to-scrape-artmajeurcom)
- [You might also like](#you-might-also-like)
- [FAQ](#faq)

### 🔑 Key features

- **Two entity types, one Actor.** Set `entityType` to `artworks` or `artists` — no need for two
  separate scrapers to build a full picture of an artist and their work.
- **Real per-artist rollup stats, not a sample.** Average price, unique medium mix, sold-artwork
  count, and latest artwork are computed from an artist's **entire** catalog, enumerated via
  Artmajeur's own per-artist RSS feed (paginated to completion).
- **Delta mode built in.** Every run classifies each item as `new`, `changed`, `unchanged`, or
  `delisted` against a persisted baseline — pay for what changed, not a full re-scrape every time.
- **Exhaustive when you ask for it.** With no `startUrls`/`artistUrls`, the underlying discovery is
  the full site sitemap — every artwork (~3.1M), every artist (~108K) — but `maxItems` defaults to
  50 (a fast preview, and what keeps an unconfigured run within Apify's automated 5-minute QA
  check), so clear it (`null`) for a real full crawl. Category/sub-category narrowing was built and
  removed: its URL path segments genuinely filter server-side, but the entire `/en/artworks/*`
  route sits behind an interactive Cloudflare challenge that no plain HTTP client can pass —
  confirmed across three independent networks (see [Input](#input) and the FAQ).
- **A verified, trackable artist list.** `artistUrls` lets you scrape exactly the artists you care
  about — each URL is checked against the real sitemap first (typos/removed artists are logged and
  skipped), and unlike a generic `startUrls` list, it gets its own persisted tracking scope: run
  the same list on a schedule and get real new/changed/delisted detection for just those artists.
- **Progress visible in the run log.** Every ~10 items or ~20 seconds, the log reports how many
  items have been processed (with a known total for bounded runs), pushed, and errored, plus the
  observed rate — and for `entityType: artists`, a running count of artworks fetched across all
  rollups so far.
- **Confirmed-dead URLs are never re-fetched.** A real run found 58% of a sitemap sample were
  already HTTP 410 Gone (genuinely deactivated/removed accounts still listed in Artmajeur's own
  sitemap) — every 410 is now persisted (per entity type, including artwork URLs found inside an
  artist's rollup) and skipped on every future run, no input needed to enable it.

### 📋 Output

One dataset item per artwork or artist, depending on `entityType` — see
[`.actor/dataset_schema.json`](.actor/dataset_schema.json) for the full field list, or the
Output tab's **Artworks** / **Artists** views for a readable table.

**Example artwork record:**

```json
{
  "source": "artmajeur",
  "entity_type": "artworks",
  "external_id": "artmajeur_16257",
  "url": "https://www.artmajeur.com/serge-reynaud-art-of-flying/en/artworks/16257/aquila-nuvole",
  "title": "Aquila Nuvole",
  "artist_name": "Serge Reynaud (Art of Flying)",
  "artist_url": "https://www.artmajeur.com/serge-reynaud-art-of-flying/en",
  "category": "Sculpture",
  "technique": "Sculpture",
  "price": 16301,
  "currency": "EUR",
  "availability_status": "InStock",
  "height_cm": 60.0,
  "width_cm": 70.0,
  "change_type": "new"
}
```

**Example artist record:**

```json
{
  "source": "artmajeur",
  "entity_type": "artists",
  "external_id": "samuel",
  "url": "https://www.artmajeur.com/samuel",
  "name": "Samuel Charmetant",
  "country": "FR",
  "city": "CLAPIERS",
  "job_title": "Photographer",
  "followers": 76,
  "total_artworks": 42,
  "sold_artworks": 5,
  "avg_price": 340.5,
  "mediums": "Photography",
  "change_type": "new"
}
```

Results can be downloaded as JSON, CSV, or Excel from the Console's Output tab, or pulled via the
Apify API/dataset endpoint.

**Known gaps:**

- Artwork `depth_cm` is only populated when Artmajeur's own dimensions text uses the labeled
  "Height/Width/Depth" format — the bare compact format (`"53x43 cm"`) never showed a third number
  live, and its two-number order (assumed Height x Width) still isn't independently confirmable
  from any other field on the page.
- A sold artwork (`availability_status: "Sold"`) always has `price`/`currency` as `null` — the
  page genuinely doesn't redisplay a price for sold items, confirmed against a real example.
- `price`/`currency` (and the artist rollup's `avg_price`/`sold_avg_price`/`latest_artwork_price`)
  are native, unconverted values — Artmajeur geo-detects displayed currency by the requester's IP,
  so the same artwork can show different currencies depending on which IP/proxy scrapes it. The
  rollup's averaging assumes one currency across an artist's whole catalog (the common case) — it
  does not detect or convert mixed currencies.
- No category/sub-category narrowing input — see Key features and the FAQ.

### ⚙️ Input

See [`.actor/input_schema.json`](.actor/input_schema.json) for the full JSON schema.

| Parameter | Type | Default | Description |
|---|---|---|---|
| `entityType` | String | `artworks` | `artworks` or `artists`. |
| `startUrls` | Array of strings | *(none)* | Specific artist or artwork URLs to scrape directly, instead of discovering via the full site sitemap. Scope is always `"custom"`, with no persisted tracking across runs — for persisted per-artist tracking, use `artistUrls` instead, which also checks each URL against the site's member sitemap. |
| `artistUrls` | Array of strings | *(none)* | Artists only. Paste artist URLs, one per line (a `.txt` file's contents paste in directly, no upload needed) to scrape exactly those artists + their artworks. Verified against the real member sitemap first (see `verifyArtistUrls`); gets its own persisted scope, so re-running the same list on a schedule gives real new/changed/delisted tracking for just those artists. Takes priority over `startUrls`. |
| `verifyArtistUrls` | Boolean | `true` | When `artistUrls` is set, check each URL against the real sitemap first (~2 minutes, one full sitemap walk, regardless of list size) and skip any not found. Turn off to scrape the list unverified. |
| `maxItems` | Integer | `50` | Stop after pushing this many dataset items. Defaults to a fast, cheap preview (also what keeps an unconfigured run within Apify's automated 5-minute QA check — this actor paces requests to 1/sec, so an uncapped default run could never pass that check regardless of speed). A full crawl covers the entire site (millions of artworks, or the full ~108K-artist directory) — raise this or clear it (set to `null`) for that; note a capped run never updates the incremental baseline (see below), so any real tracking run needs this cleared. |
| `mode` | String | `auto` | `auto` (recommended): full scan on the first run, incremental after. `full`: always push every item and refresh the baseline. `incremental`: always push only new/changed items. Only a plain, unscoped sitemap crawl can detect delistings or update the baseline. |
| `impersonate` | String | `chrome` (internal) | curl\_cffi TLS-impersonation target. Artmajeur's Cloudflare protection challenges plain requests, so this is set internally by default — override only if that stops working. |
| `proxyConfiguration` | Object | `{"useApifyProxy": false}` | Apify Proxy config. Off by default — the sitemap/profile/detail pages this Actor relies on worked fine without one while building it. |

### 🧪 Input examples

**Full artwork catalog scan** (exhaustive, slow — every artwork's detail page is fetched;
`maxItems: null` explicitly overrides the 50-item default):

```json
{ "entityType": "artworks", "maxItems": null }
```

**Bounded preview** (the default — fast, but not a curated subset, just the first N artworks the
sitemap yields):

```json
{ "entityType": "artworks", "maxItems": 200 }
```

**Full artist directory, with rollup stats:**

```json
{ "entityType": "artists", "maxItems": null }
```

**A specific, tracked list of artists** (verified against the sitemap, own persisted scope —
`maxItems: null` so the whole list is scraped even if it's longer than the 50-item default):

```json
{
  "entityType": "artists",
  "artistUrls": [
    "https://www.artmajeur.com/samuel",
    "https://www.artmajeur.com/serge-reynaud-art-of-flying"
  ],
  "maxItems": null
}
```

**Scheduled tracking run** — full, uncapped run (`maxItems` cleared — required for the baseline to
save and delistings to be detected):

```json
{ "entityType": "artworks", "mode": "incremental", "maxItems": null }
```

### 🔄 Incremental (delta) mode

Every run classifies each item as `new`, `changed` (price or availability moved, for artworks;
catalog size/sold-count/avg-price moved, for artists), `unchanged`, or `delisted`, using a state
baseline persisted in a named Apify Key-Value Store scoped to `entityType`.

- `mode: auto` (default) — first run for a scope pushes everything (`full`); later runs push only
  `new`/`changed`/`delisted` (`incremental`).
- A `startUrls`-scoped run is always partial and never updates the baseline. `artistUrls` is
  different: it's treated as a complete, closed universe (like a full sitemap crawl), so its
  baseline does get saved and delisted-detection does run — as long as no item hit a genuinely
  ambiguous error that run (a confirmed HTTP 410 doesn't count against this — see below; a timeout,
  5xx, or parse error does, and skips the baseline-save/delisted-detection that run to avoid false
  "delisted" reports).
- Every bounded run (`startUrls` or `artistUrls`) logs a quick "X new, Y already tracked, Z
  already known-dead" preview right after startup, before the full fetch loop begins —
  new/already-tracked is informational only (every URL is still fully fetched and classified
  regardless, real price/status-change detection isn't skipped for "already tracked" items);
  already-known-dead URLs genuinely are skipped, see below.
- A URL confirmed permanently gone (HTTP 410) is recorded and never fetched again on any future
  run, regardless of `mode` or scope — logged distinctly from other errors. Doesn't count toward
  the baseline-save/delisted-detection gate above, since it's a trustworthy, already-understood
  outcome rather than an ambiguous failure.

Full design: [`docs/incremental-mode.md`](../../docs/incremental-mode.md).

### 🚀 How to scrape Artmajeur.com

1. Open the Artmajeur Artist & Artwork Scraper in Apify Console and go to the **Input** tab.
2. Pick `entityType` (`artworks` or `artists`).
3. `maxItems` defaults to 50 (a quick preview) — clear it (set to `null`) for a full, uncapped run.
4. Click **Start**.
5. When the run finishes, browse results in the **Output** tab, or download as JSON/CSV/Excel, or
   fetch them via the API.
6. To track over time instead of scraping once: create a **Schedule** with `mode: auto` — the
   first run does a full scan, every run after only bills what actually changed.

### 🔗 You might also like

- **[SaatchiArt Artist & Artwork Scraper](https://apify.com/artsiom_k/saatchiart-scraper)** — the
  same entity-type/rollup-stats design pointed at a second, independent art marketplace, for
  expanding artist coverage or cross-referencing the same artist's presence and pricing across
  platforms.
- **[Artsper Artist & Artwork Scraper](https://apify.com/artsiom_k/artsper-scraper)** — a third,
  independent art marketplace source, same design.

### ❓ FAQ

**Is it legal to scrape Artmajeur.com?** It's legal to collect publicly available marketplace data
such as artwork listings, prices, and public artist profile information. Scrape it only with a
legitimate purpose under GDPR.

**How do I get only new/changed items?** Use `mode: auto` (or `incremental`) on a schedule — see
[Incremental mode](#incremental-delta-mode).

**Why doesn't this Actor support filtering by category, price, style, subject, or country?**
Artmajeur's catalog/browse pages (`/en/artworks/...`) sit behind an interactive Cloudflare
challenge — confirmed while building this actor across three independent networks (a home/office
IP, a datacenter proxy, and Apify's own datacenter proxy group), all three blocked on that route
while sitemap/profile/artwork-detail requests on the same sessions stayed open throughout. That's
not a rate-limit issue pacing or a different IP can fix — it needs either a properly-provisioned
unblocking proxy or browser automation, neither of which this Actor currently uses. Use `maxItems`
for a bounded preview instead.

### Search keywords

artmajeur scraper, art marketplace scraper, artist data scraper, artwork data scraper, art price
data, art market analytics, art collector data feed

# Actor input Schema

## `entityType` (type: `string`):

Scrape artworks or artist profiles. Each produces a different output shape (see dataset\_schema.json).

## `startUrls` (type: `array`):

Optional list of specific Artmajeur artist or artwork URLs to scrape directly, instead of discovering via the full site sitemap — use whichever kind matches entityType. For artists specifically, consider artistUrls below instead: it checks each URL against the site's member sitemap and gets its own persisted tracking across repeat runs.

## `artistUrls` (type: `array`):

Paste a list of specific Artmajeur artist URLs (one per line — paste a .txt file's contents directly, no upload needed) to scrape exactly those artists and their artworks, instead of crawling the full site. Each URL is checked against the real member sitemap first (found/not-found is logged; not-found ones are skipped) unless verifyArtistUrls is off. Unlike startUrls, this list gets its own persisted tracking scope — re-running the same list on a schedule gives real new/changed/delisted detection for just those artists. Ignored when entityType is "artworks" or startUrls is set.

## `verifyArtistUrls` (type: `boolean`):

When artistUrls is set, check each URL against the real member sitemap before scraping (adds one full sitemap walk, ~2 minutes, regardless of list size) and skip any not found. Turn off to scrape the list as given, unverified.

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

Stop after pushing this many dataset items. Defaults to 50 — a fast, cheap preview, and what keeps an unconfigured run within Apify's automated 5-minute QA check (this actor paces requests to 1/sec, so an uncapped default run could never finish that check regardless of speed). A full, uncapped sitemap crawl covers the entire site — millions of artworks, or the full ~108K-artist directory — raise this or clear it (set to null) for that.

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

"auto" (recommended): full scan on the first run for a given entityType/scope, incremental (new/changed only) afterwards. "full": always push every item and refresh the baseline — schedule this periodically to catch delistings. "incremental": always push only new/changed items. Only a plain, unscoped sitemap crawl (no startUrls) can detect delistings or update the baseline — see docs/incremental-mode.md.

## `impersonate` (type: `string`):

curl\_cffi browser TLS-impersonation target. Artmajeur.com's Cloudflare protection challenges plain (non-impersonated) requests, so this defaults to "chrome" internally — override only if that stops working.

## `proxyConfiguration` (type: `object`):

Apify Proxy configuration. Leave off unless you start seeing blocks from your own IP reputation; if so, try residential rather than datacenter groups.

## Actor input object example

```json
{
  "entityType": "artworks",
  "verifyArtistUrls": true,
  "maxItems": 50,
  "mode": "auto",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("artsiom_k/artmajeur-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,artsiom_k/artmajeur-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/MexszAGbMxgAyHnHE/builds/k7TvLCZpf4NfcxEH6/openapi.json