# Openverse Creative Commons Media Scraper: CC0 Images & Audio (`scrapers_lat/openverse-cc-media-scraper`) Actor

Search openly-licensed Creative Commons and public-domain images and audio from Openverse (Flickr, Wikimedia, museums, Jamendo). Every asset returns its license, human-readable label, ready-to-use attribution, provider and commercial-use flags. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/scrapers\_lat/openverse-cc-media-scraper.md
- **Developed by:** [Scrapers Lat](https://apify.com/scrapers_lat) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.32 / 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 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

[![Openverse Creative Commons Media Scraper: CC0 Images & Audio](https://scrapers.lat/banners/openverse-cc-media-scraper.png)](https://apify.com/scrapers_lat/openverse-cc-media-scraper)

## Openverse Creative Commons Media Scraper: CC0 Images & Audio

Search openly-licensed, royalty-free images and audio and get the license, attribution and source provenance for every asset, so you can reuse it legally. Here is one real result, with every field the actor returns:

```json
{
  "id": "89f5ff02-d895-455c-9c9c-cd8dd934c8bf",
  "mediaType": "image",
  "title": "You Looking at Me? Mountains goats in Glacier National Park, Montana",
  "creator": "U.S. Geological Survey",
  "creatorUrl": "https://www.flickr.com/photos/27784370@N05",
  "license": "cc0",
  "licenseVersion": "1.0",
  "licenseUrl": "https://creativecommons.org/publicdomain/zero/1.0/",
  "licenseLabel": "CC0 1.0",
  "commercialUse": true,
  "modificationsAllowed": true,
  "url": "https://live.staticflickr.com/5550/13974169513_5e21ce9b9a.jpg",
  "thumbnail": "https://api.openverse.org/v1/images/89f5ff02-d895-455c-9c9c-cd8dd934c8bf/thumb/",
  "foreignLandingUrl": "https://www.flickr.com/photos/27784370@N05/13974169513",
  "provider": "flickr",
  "source": "flickr",
  "category": null,
  "width": 500,
  "height": 339,
  "filetype": null,
  "filesize": null,
  "durationMs": null,
  "bitRate": null,
  "sampleRate": null,
  "genres": null,
  "waveform": null,
  "tags": ["alpine", "climatechange", "glacier", "glaciernationalpark", "habitats", "mammals"],
  "tagCount": 10,
  "attribution": "\"You Looking at Me? Mountains goats in Glacier National Park, Montana\" by U.S. Geological Survey is marked with CC0 1.0. To view the terms, visit https://creativecommons.org/publicdomain/zero/1.0/.",
  "relatedUrl": "https://api.openverse.org/v1/images/89f5ff02-d895-455c-9c9c-cd8dd934c8bf/related/",
  "detailFetched": false,
  "aiAltText": null,
  "aiCaption": null,
  "aiSeoKeywords": null,
  "detailUrl": "https://api.openverse.org/v1/images/89f5ff02-d895-455c-9c9c-cd8dd934c8bf/",
  "searchQuery": "mountain",
  "observedAt": "2026-08-17T01:24:21.071Z"
}
```

The complete Creative Commons media search in one actor. It returns openly-licensed and public-domain images and audio aggregated from Flickr, Wikimedia Commons, museums, Jamendo and more, and for every asset it gives you the exact license, a human-readable license label, a ready-to-use attribution string, and derived `commercialUse` and `modificationsAllowed` flags. That is what turns a random image URL into media you can safely reuse.

**📥 [Input](https://apify.com/scrapers_lat/openverse-cc-media-scraper/input-schema) · 📤 [Output](https://apify.com/scrapers_lat/openverse-cc-media-scraper/output-schema) · 💰 [Pricing](https://apify.com/scrapers_lat/openverse-cc-media-scraper/pricing) · ▶️ [Examples](https://apify.com/scrapers_lat/openverse-cc-media-scraper/examples)**

![Apify](https://img.shields.io/badge/Platform-Apify-1CE1CE?logo=apify\&logoColor=white)
![Coverage](https://img.shields.io/badge/Media-Images%20%7C%20Audio-blue)
![License](https://img.shields.io/badge/License-CC0%20%7C%20CC%20BY%20%7C%20Public%20Domain-brightgreen)
![Output](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-orange)

### Table of contents

- [What it does](#what-it-does)
- [Use cases](#use-cases)
- [Quickstart](#quickstart)
- [Input reference](#input-reference)
- [Output reference](#output-reference)
- [Run via API and CLI](#run-via-api-and-cli)
- [Fetch results](#fetch-results)
- [Billing and limits](#billing-and-limits)
- [FAQ and troubleshooting](#faq-and-troubleshooting)

### What it does

The actor searches the Openverse catalog of openly-licensed media by keyword and writes one record per media item to the run's dataset. Choose images or audio, then narrow with filters for license code, commercial or modification usage, provider, category, file extension, image aspect ratio and size, and creator. Every record carries the direct file URL, thumbnail, original source page, provider and source, dimensions, tags, and the full licensing block: `license`, `licenseVersion`, `licenseUrl`, a human-readable `licenseLabel` such as `CC BY-SA 4.0`, a ready-to-paste `attribution` string, and the derived `commercialUse` and `modificationsAllowed` booleans so you instantly know how each asset may be used.

Two optional add-ons (paid Apify plans only) enrich each item. `includeDetail` fetches the per-item detail endpoint to add the complete tag set, a related-media link and any metadata the search list omits. `withAiCaption` generates accessibility alt text, an SEO caption and keywords from the item's title and tags. Note that the AI caption is produced from the item metadata only; the model does not see the image or audio itself. Missing values are always returned as `null`, never invented.

### Use cases

- **Royalty-free media libraries.** Build a searchable library of CC0 images, public-domain photos and stock media that your team can reuse without licensing risk.
- **Attribution-clean blogging and design.** Grab commercially-usable stock photos with a ready-made credit line for blog posts, presentations, newsletters and social media.
- **ML and AI training datasets.** Assemble openly-licensed image and audio datasets for machine learning, filtered to `commercialUse` and `modificationsAllowed` so the training data is safe to use.
- **Accessibility and SEO.** Use the AI caption add-on to generate alt text and SEO keywords for every reused asset.
- **Licensing compliance audits.** Verify the license, version and attribution requirement of media before publishing, at scale.
- **Music and sound sourcing.** Find Creative Commons audio, tracks and sound effects for videos, podcasts and games with duration, genre and license in every row.

### Quickstart

Open the actor, paste this into the input, and press Run. It returns up to 50 CC0 (public-domain) photographs of mountains.

```json
{
  "mediaType": "image",
  "query": "mountain",
  "license": "cc0",
  "maxResults": 50
}
```

Change `query` to any keyword, switch `mediaType` to `audio` for music and sound, or set `licenseType` to `commercial` to restrict to commercially-usable media. Every filter is optional.

### Input reference

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `mediaType` | string | no | `image` | Which catalog to search: `image` or `audio`. |
| `query` | string | no | `mountain` | Keywords to search for, for example `sunset`, `jazz`, `vintage poster`. |
| `license` | string | no | `cc0` | Comma-separated Creative Commons license codes: `cc0`, `pdm`, `by`, `by-sa`, `by-nc`, `by-nd`, `by-nc-sa`, `by-nc-nd`. |
| `licenseType` | string | no | (any) | Usage filter: `commercial`, `modification`, or `both`. |
| `source` | string | no | (any) | Restrict to one provider, for example `flickr`, `wikimedia`, `jamendo`, `freesound`, `met`. |
| `category` | string | no | (any) | Content category. Images: `photograph`, `illustration`, `digitized_artwork`. Audio: `music`, `sound_effect`, `podcast`, `audiobook`, `news`. |
| `extension` | string | no | (any) | File type. Images: `jpg`, `png`, `gif`, `svg`. Audio: `mp3`, `ogg`, `flac`, `wav`. |
| `aspectRatio` | string | no | (any) | Image shape: `tall`, `wide`, `square`. |
| `size` | string | no | (any) | Image resolution: `small`, `medium`, `large`. |
| `creator` | string | no | (any) | Only return media by this creator or artist name. |
| `maxResults` | integer | no | `50` | Maximum number of media items to collect across all pages. |
| `includeDetail` | boolean | no | `false` | Paid add-on. Enrich each item from its detail endpoint (full tags, related media, extra metadata). Billed per item on a successful detail fetch. |
| `withAiCaption` | boolean | no | `false` | Paid AI add-on. Generate alt text, an SEO caption and keywords from the item's title and tags. Billed per item captioned. |

### Output reference

One dataset item per media asset. Types: `string`, `integer`, `boolean`, `string[]`, or `null` when the source value is absent.

| Field | Type | Description |
|---|---|---|
| `id` | string | Openverse media item ID. |
| `mediaType` | string | `image` or `audio`. |
| `title` | string | Media title. |
| `creator` | string | Creator or artist name, or `null`. |
| `creatorUrl` | string | Creator profile URL, or `null`. |
| `license` | string | Creative Commons license code, for example `by-sa`. |
| `licenseVersion` | string | License version, for example `4.0`. |
| `licenseUrl` | string | URL of the license deed. |
| `licenseLabel` | string | Human-readable label, for example `CC BY-SA 4.0` or `CC0 1.0`. |
| `commercialUse` | boolean | Whether the license allows commercial use (derived from the license code). |
| `modificationsAllowed` | boolean | Whether the license allows modifications or derivatives (derived from the license code). |
| `url` | string | Direct URL of the media file. |
| `thumbnail` | string | Thumbnail image URL. |
| `foreignLandingUrl` | string | Original source page URL. |
| `provider` | string | Aggregated provider, for example `flickr`, `wikimedia`. |
| `source` | string | Original media source. |
| `category` | string | Content category, or `null`. |
| `width` | integer | Image width in pixels, or `null`. |
| `height` | integer | Image height in pixels, or `null`. |
| `filetype` | string | File type, for example `jpg`, `mp3`, or `null`. |
| `filesize` | integer | File size in bytes, or `null`. |
| `durationMs` | integer | Audio duration in milliseconds (audio only), or `null`. |
| `bitRate` | integer | Audio bit rate (audio only), or `null`. |
| `sampleRate` | integer | Audio sample rate (audio only), or `null`. |
| `genres` | string\[] | Audio genres (audio only), or `null`. |
| `waveform` | string | Audio waveform data URL (audio only), or `null`. |
| `tags` | string\[] | Tag names describing the media. |
| `tagCount` | integer | Number of tags. |
| `attribution` | string | Ready-to-use attribution / credit string. |
| `relatedUrl` | string | URL for related media. |
| `detailFetched` | boolean | Whether the detail add-on enriched this item. |
| `aiAltText` | string | AI-generated accessibility alt text when the add-on is enabled, else `null`. |
| `aiCaption` | string | AI-generated SEO caption when the add-on is enabled, else `null`. |
| `aiSeoKeywords` | string\[] | AI-generated SEO keywords when the add-on is enabled, else `null`. |
| `detailUrl` | string | Openverse detail endpoint URL for this item. |
| `searchQuery` | string | Search query that produced this record. |
| `observedAt` | string | ISO 8601 timestamp of when the record was collected. |
| `error` | string | Present only on a failed run; a single item with a populated `error` field is written instead. |

### Run via API and CLI

Start a run and wait for it to finish, then read the dataset. Replace `<TOKEN>` with your Apify API token.

Run synchronously and get dataset items in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers_lat~openverse-cc-media-scraper/run-sync-get-dataset-items?token=<TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mediaType":"image","query":"mountain","license":"cc0","maxResults":50}'
```

Start a run asynchronously:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers_lat~openverse-cc-media-scraper/runs?token=<TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mediaType":"audio","query":"jazz","license":"cc0,by","maxResults":200}'
```

Apify CLI:

```bash
apify call scrapers_lat/openverse-cc-media-scraper \
  --input '{"mediaType":"image","query":"sunset","licenseType":"commercial"}'
```

### Fetch results

Every run writes to a dataset. Fetch items as JSON, CSV, or Excel by changing `format`:

```bash
## JSON
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?token=<TOKEN>&clean=true&format=json"

## CSV
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?token=<TOKEN>&clean=true&format=csv"

## Paginate large datasets
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?token=<TOKEN>&offset=1000&limit=1000"
```

`<DATASET_ID>` is returned as `defaultDatasetId` in the run object. Use `offset` and `limit` to page through large result sets. `clean=true` drops empty and internal fields.

### Billing and limits

- **Pay per result.** You are charged per media item returned (`result` event). See the [pricing tab](https://apify.com/scrapers_lat/openverse-cc-media-scraper/pricing) for the current per-result price.
- **Add-ons billed separately.** `detail` is charged per item only on a successful detail fetch, and `ai_caption` is charged per item only when the model returns usable output. Both add-ons are opt-in and available on paid Apify plans only.
- **No charge on failure.** If a run errors, the actor writes a single item with a populated `error` field and does not charge for it. Empty and zero-result runs cost nothing.
- **Spend cap respected.** Set `maxTotalChargeUsd` on the run; once reached, the actor stops emitting and charging further billable results.
- **Free Apify plans** are capped at 10 items per run and cannot use the paid add-ons. Upgrade for higher `maxResults`.

### FAQ and troubleshooting

**Is the media really free to use?**
Yes, subject to its license. Every record includes the license code, a human-readable label and the exact attribution string. Assets marked `commercialUse: true` and `modificationsAllowed: true` are the most permissive. Public-domain items (`cc0`, `pdm`) need no attribution, though crediting the creator is good practice.

**How are `commercialUse` and `modificationsAllowed` decided?**
They are derived from the Creative Commons license code: `commercialUse` is false when the license carries the NonCommercial (`nc`) term, and `modificationsAllowed` is false when it carries the NoDerivatives (`nd`) term. Always confirm against the linked `licenseUrl` for your specific use.

**Can I search audio as well as images?**
Yes. Set `mediaType` to `audio` to search Creative Commons music, tracks and sound effects, with `durationMs`, `bitRate`, `genres` and a `waveform` link on each row.

**What does the AI caption add-on actually see?**
It generates alt text, a caption and SEO keywords from the item's title and tags only. It does not analyze the image or audio file itself, so treat the output as metadata-derived assistance.

**A run returned 0 records. Why?**
Your query and filters matched no media. Try a broader keyword or remove filters such as `license`, `source` or `extension`. Zero-result runs are not charged.

**Is this an official Openverse or Creative Commons tool?**
No. This actor is independent and has no affiliation with Openverse, WordPress or Creative Commons. It reads only openly-licensed media metadata that is publicly available.

### Related scrapers

- [Discogs Scraper](https://apify.com/scrapers_lat/discogs-scraper): Music releases, artists and marketplace data.
- [TikTok Creative Center Scraper](https://apify.com/scrapers_lat/tiktok-creative-center-scraper): Trending sounds, hashtags and ads.

### More scrapers at scrapers.lat

Built and maintained by [scrapers.lat](https://scrapers.lat), where we publish scrapers for public platforms: company registries, government data, finance, e-commerce, media and more. Browse the catalog or request a custom scraper at [scrapers.lat](https://scrapers.lat).

***

> Independent tool, not affiliated with Openverse, WordPress or Creative Commons. Accesses only publicly available openly-licensed media metadata.

# Actor input Schema

## `mediaType` (type: `string`):

Which Openverse catalog to search: openly-licensed images or audio.

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

Keywords to search for, e.g. 'mountain', 'jazz', 'vintage poster'. Combine with the filters below to narrow results.

## `license` (type: `string`):

Comma-separated Creative Commons license codes to restrict results: cc0, pdm, by, by-sa, by-nc, by-nd, by-nc-sa, by-nc-nd. Example: 'cc0,by' for the most permissive, reuse-friendly media.

## `licenseType` (type: `string`):

Filter by how the media may be used: commercial (allows commercial use), modification (allows edits/derivatives), or both.

## `source` (type: `string`):

Restrict to a single provider, e.g. flickr, wikimedia, jamendo, freesound, met (The Met), smithsonian\_\*.

## `category` (type: `string`):

Content category. Images: photograph, illustration, digitized\_artwork. Audio: music, sound\_effect, podcast, audiobook, news.

## `extension` (type: `string`):

Restrict to a file type. Images: jpg, png, gif, svg. Audio: mp3, ogg, flac, wav.

## `aspectRatio` (type: `string`):

Image shape filter: tall, wide or square.

## `size` (type: `string`):

Image resolution filter: small, medium or large.

## `creator` (type: `string`):

Only return media by this creator / artist name.

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

Maximum number of media items to collect across all pages.

## `includeDetail` (type: `boolean`):

When enabled, each item is enriched from its detail endpoint with the complete tag set, related-media link and any metadata the search list omits (filesize, filetype, category). Charged per item on a successful detail fetch. Paid plans only.

## `withAiCaption` (type: `boolean`):

Use AI to generate accessibility alt text, an SEO caption and keywords for each item from its title and tags (the model does not see the file itself). Charged per item captioned. Paid plans only.

## Actor input object example

```json
{
  "mediaType": "image",
  "query": "mountain",
  "license": "cc0",
  "licenseType": "",
  "maxResults": 50,
  "includeDetail": false,
  "withAiCaption": 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 = {
    "query": "mountain",
    "license": "cc0",
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers_lat/openverse-cc-media-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 = {
    "query": "mountain",
    "license": "cc0",
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers_lat/openverse-cc-media-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 '{
  "query": "mountain",
  "license": "cc0",
  "maxResults": 50
}' |
apify call scrapers_lat/openverse-cc-media-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers_lat/openverse-cc-media-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/pEAJ2Z5oYDlhvcc8c/builds/lDnclcO14FlKsqpPY/openapi.json