# SMK Denmark Collection Scraper (`parseforge/smk-denmark-collection-scraper`) Actor

Reach the Statens Museum for Kunst open collection and pull artwork records with image URL, title, artist, year, medium, dimensions, collection, and artwork URL. Filter by query, artist, image availability, or public domain status for art research, education, and creative work.

- **URL**: https://apify.com/parseforge/smk-denmark-collection-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Integrations, Education
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 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.
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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🖼️ SMK Denmark Collection Scraper

> 🚀 **Export SMK Denmark Open Collection data in seconds. Clean records straight from the public source, ready for spreadsheets, BI tools, and warehouses.**

> 🕒 **Last updated.** 2026-06-05 · **📊 10 fields** per record · Public source · No login required

The SMK Denmark Collection Scraper turns the public [SMK Denmark Open Collection](https://open.smk.dk/en/search) source into a clean, structured dataset. It walks the public listing, parses each record, and pushes one row per result into an Apify dataset that you can download in seconds.

This actor scrapes only data already visible to anyone visiting the source without logging in. No credentials, no member-only content.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| 📊 Analysts | Pull a structured copy of the SMK Denmark Open Collection feed for analysis. |
| 🏢 Business teams | Build market maps and lead lists. |
| 🤖 ML engineers | Build training and benchmark datasets. |
| 📰 Journalists | Verify and cross-reference facts at scale. |
| 👩‍💻 Developers | Avoid writing one-off scrapers. |

### 📋 What the SMK Denmark Collection Scraper does

- Fetches the public SMK Denmark Open Collection listing or API.
- Parses each record into a flat row with normalized field names.
- Surfaces upstream errors as a single record with the `error` field populated instead of crashing.
- Streams results into an Apify dataset for instant download.

> 💡 **Why it matters.** The SMK Denmark Open Collection source presents this data as pages built for humans, not pipelines. This actor flattens it into rows your tools can read without writing custom parsers.

### 🎬 Full Demo

_🚧 Coming soon._

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Required</th><th>Description</th></tr>
<tr><td><code>query</code></td><td>string</td><td>No</td><td>Free-text search query.</td></tr>
<tr><td><code>artist</code></td><td>string</td><td>No</td><td>Artist name filter.</td></tr>
<tr><td><code>hasImage</code></td><td>boolean</td><td>No</td><td>Only works with images.</td></tr>
<tr><td><code>publicDomain</code></td><td>boolean</td><td>No</td><td>Only public domain works.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>No</td><td>Free users 10, paid users up to 1,000,000. Prefill 10.</td></tr>
</table>

**Example 1.**
```json
{
  "artist": "Hammershoi",
  "hasImage": true,
  "maxItems": 25
}
````

**Example 2.**

```json
{
  "query": "landscape",
  "publicDomain": true,
  "maxItems": 10
}
```

> ⚠️ **Good to Know.** SMK Denmark provides a public open data API. This actor calls it directly.

### 📊 Output

Each record is a flat object. `error` is always last.

| Field | Type | Description |
|---|---|---|
| 🖼️ Image `imageUrl` | text | Field from the SMK Denmark Open Collection record. |
| 📜 Title `title` | text | Field from the SMK Denmark Open Collection record. |
| 🎨 Artist `artist` | text | Field from the SMK Denmark Open Collection record. |
| 📅 Year `year` | text | Field from the SMK Denmark Open Collection record. |
| 🎭 Medium `medium` | text | Field from the SMK Denmark Open Collection record. |
| 📏 Dimensions `dimensions` | text | Field from the SMK Denmark Open Collection record. |
| 🏛️ Collection `collection` | text | Field from the SMK Denmark Open Collection record. |
| 🔗 URL `url` | text | Field from the SMK Denmark Open Collection record. |
| 🕒 `scrapedAt` | string | When the row was collected. |
| ❌ `error` | string | Populated if the upstream response was an error. |

**Sample record.**

```json
{
  "imageUrl": null,
  "title": null,
  "artist": null,
  "year": null,
  "medium": null,
  "dimensions": null,
  "collection": null,
  "url": null,
  "scrapedAt": "2026-06-05T12:00:00.000Z",
  "error": null
}
```

### ✨ Why choose this Actor

| 🆓 | Works on the public source without login. |
| 🧹 | Clean, normalized field names ready for analytics. |
| 🛟 | Errors surfaced as a clean diagnostic record, not a crash. |
| 💾 | Push to dataset, instant download in any supported format. |

### 📈 How it compares to alternatives

| Approach | Setup time | Clean fields | Pagination | Error handling |
|---|---|---|---|---|
| Roll your own fetch | 30 min plus | ❌ | manual | ❌ |
| Browser automation | 1 hr plus | partial | manual | partial |
| **This Actor** | 5 sec, no install | ✅ | ✅ | ✅ |

### 🚀 How to use

1. Click **Try for free**.
2. Fill in the optional filters or accept the prefills.
3. Set `maxItems` (or leave the prefill of 10).
4. Click **Start**. Download the dataset in seconds.

### 💼 Business use cases

**📊 Market mapping.** Build a structured view of the SMK Denmark Open Collection landscape for strategy work.

**📈 Lead generation.** Turn the listing into a starting list for outbound research.

**🧠 Competitive intelligence.** Track changes between runs over time.

**🤖 ML and analytics.** Use the dataset as a clean input for downstream pipelines.

### 🔌 Automating SMK Denmark Collection Scraper

- **Make and Zapier.** Trigger the actor on a schedule, push results to Airtable, Sheets, or Slack.
- **Cron schedule.** Use the native Apify scheduler.
- **Webhooks.** Get notified the moment a run finishes.
- **Warehouses.** Pipe results to BigQuery, Snowflake, or Postgres.

### 🌟 Beyond business use cases

**🎓 Education.** Use the dataset as a teaching example in data classes.

**🧪 Personal research.** Power side projects with structured public data.

**🤝 Non-profit and open data.** Build public dashboards on top of the dataset.

**🧰 Tinkering and prototyping.** Spin up a feed in minutes for a new tool.

### 🤖 Ask an AI assistant about this scraper

Drop this README into ChatGPT, Claude, or any AI assistant and ask it to map your workflow to the actor's inputs.

### ❓ Frequently Asked Questions

**❓ Do I need an account on the source site?** No. The actor uses only public pages and endpoints.

**❓ Are there rate limits?** The actor is conservative by default. If the source returns an error, you will see a clean `error` record.

**❓ Can I schedule runs?** Yes, via the Apify scheduler or any external trigger.

**❓ What output formats are supported?** All formats supported by Apify datasets.

**❓ Will fields ever be missing?** Yes, when the source page does not include them. They will be `null` instead of a hard failure.

**❓ Will the schema change?** The core fields are stable. New optional fields may be added over time.

**❓ Is the output deterministic?** Order follows the source listing. Re-runs return the same shape but content can change as the site updates.

**❓ Can I integrate with my warehouse?** Yes, via native Apify integrations.

**❓ Can I run this from a script?** Yes, via the Apify API or any SDK.

**❓ Can I extend the actor?** Yes, fork it on Apify or run a custom build.

### 🔌 Integrate with any app

Apify ships native integrations with Make, Zapier, Slack, Discord, Google Drive, Google Sheets, Gmail, Airbyte, Keboola, Telegram, GitHub, and any REST or webhook endpoint. Pipe results straight into BigQuery, Snowflake, or Postgres.

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [ParseForge OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database. |
| [ParseForge Yahoo Finance Scraper](https://apify.com/parseforge) | Equities, funds, indices, options. |
| [ParseForge NBA Stats Scraper](https://apify.com/parseforge/nba-stats-scraper) | Player and team stats. |
| [ParseForge Alpha Vantage Scraper](https://apify.com/parseforge/alpha-vantage-public-scraper) | Market data and indicators. |

> 💡 **Pro Tip.** Browse the complete [ParseForge collection](https://apify.com/parseforge) for 900 plus production-grade scrapers across business intelligence, real estate, e-commerce, sports, finance, and public records.

***

**Disclaimer.** This actor scrapes only publicly available data. ParseForge is not affiliated with, endorsed by, or sponsored by any of the third-party services referenced. Users are responsible for complying with the target site's terms of service and applicable law. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp).

# Actor input Schema

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

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

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

Free-text query (e.g. Hammershoi, landscape, portrait).

## `artist` (type: `string`):

Filter by artist name.

## `hasImage` (type: `boolean`):

Only return works with a usable image.

## `publicDomain` (type: `boolean`):

Only return public domain works.

## Actor input object example

```json
{
  "maxItems": 10,
  "hasImage": true
}
```

# 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 = {
    "maxItems": 10
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/smk-denmark-collection-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call parseforge/smk-denmark-collection-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SMK Denmark Collection Scraper",
        "description": "Reach the Statens Museum for Kunst open collection and pull artwork records with image URL, title, artist, year, medium, dimensions, collection, and artwork URL. Filter by query, artist, image availability, or public domain status for art research, education, and creative work.",
        "version": "0.1",
        "x-build-id": "kaZliueG43TdiHXGi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~smk-denmark-collection-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-smk-denmark-collection-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~smk-denmark-collection-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-smk-denmark-collection-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~smk-denmark-collection-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-smk-denmark-collection-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text query (e.g. Hammershoi, landscape, portrait)."
                    },
                    "artist": {
                        "title": "Artist name",
                        "type": "string",
                        "description": "Filter by artist name."
                    },
                    "hasImage": {
                        "title": "Has image",
                        "type": "boolean",
                        "description": "Only return works with a usable image.",
                        "default": true
                    },
                    "publicDomain": {
                        "title": "Public domain only",
                        "type": "boolean",
                        "description": "Only return public domain works."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
