# Creative Commons Scraper - Openverse, $0.0005/Result (`gio21/creative-commons-scraper`) Actor

Search Creative Commons images and audio from Openverse by keyword, with license, license-type and source filters. Full attribution text included in every result. No login needed. $0.0005 per result, the cheapest Openverse wrapper in the Store by a wide margin.

- **URL**: https://apify.com/gio21/creative-commons-scraper.md
- **Developed by:** [Gio](https://apify.com/gio21) (community)
- **Categories:** Other, Automation
- **Features:** Limited permissions
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.50 / 1,000 result returneds

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Creative Commons Scraper - Openverse, $0.0005/Result

Search Creative Commons-licensed images and audio from Openverse by
keyword, with license, attribution and source filters, no login and no
API key required.

### Why use this scraper

Anyone building a blog, a course, a product page or a video needs images
and audio they can legally use, with attribution text that will not get
them a takedown notice later. Openverse indexes hundreds of millions of
openly licensed images and audio tracks from Flickr, Wikimedia Commons,
museums, Freesound and dozens of other sources, each tagged with its exact
license. This actor turns a keyword search into a clean dataset of
results, each one already carrying the license, the license URL and a
ready-to-paste attribution string, so there is no manual lookup before
using the asset.

Doing this search by hand means visiting each source site separately,
reading its specific license terms, and writing the attribution sentence
by hand, a process that does not scale past a handful of assets. A
content team producing dozens of posts a week, or a developer populating
a stock-asset library, needs the same lookup done at bulk, with the
license and attribution already attached to each record so nothing gets
used without the right credit.

### Overview

Give the actor a search query and a media type (images or audio), and
optionally a license, license-type or source filter, and it returns one
record per result: title, creator, license, attribution text, provider,
source, direct file URL and (for images) dimensions, or (for audio)
duration. A 50-result run (the default) finishes in a few seconds. Cost
is $0.0005 per result returned, a flat rate with no separate actor-start
charge: a 1,000-result batch costs $0.50.

### Supported inputs

- **Search query** (`query`, required) - any keyword or phrase, e.g.
  `"mountain landscape"`, `"piano"`, `"vintage car"`.
- **Media type** (`mediaType`) - `images` (default) or `audio`.
- **License filter** (`license`) - comma-separated Creative Commons
  license codes: `cc0`, `pdm`, `by`, `by-sa`, `by-nc`, `by-nd`. Leave empty
  to return all licenses.
- **License type filter** (`licenseType`) - `commercial` (only licenses
  that allow commercial use) or `modification` (only licenses that allow
  derivative works), or empty for no restriction.
- **Source filter** (`source`) - restrict results to one provider, e.g.
  `flickr`, `wikimedia`, `rawpixel`, `freesound`.
- **Max results** (`maxResults`, 1 to 500, default 50) - total records to
  return.

### Use cases

- **Bloggers and content marketers** - find free-to-use header images for
  posts, with the attribution text already generated to paste in the
  credit line.
- **Course and e-learning creators** - source openly licensed diagrams,
  photos and background music without risking a copyright strike on the
  platform.
- **App and game developers** - pull CC0 (public domain) sound effects and
  images that need no attribution at all, by filtering `license=cc0`.
- **Researchers and archivists** - search across Flickr, Wikimedia Commons
  and museum collections in one query instead of visiting each site
  separately.
- **Marketing teams needing commercial-safe assets** - filter
  `licenseType=commercial` to guarantee every result returned is cleared
  for commercial use.
- **Podcast and video editors** - search `audio` for background music or
  sound effects by mood keyword, filtering to `cc0` when no attribution
  overhead is wanted in the show notes or video description.

### How it works

The actor queries the public Openverse search API (api.openverse.org),
the same open-source index that powers openverse.org, and maps each
result into a flat record with the license, attribution text and direct
file links already resolved. No login or API key is required because
Openverse's search is a public, free API; the actor just structures the
response into a dataset you can export or pipe elsewhere.

### Input configuration

**Mode 1: simple image search**

```json
{
  "query": "mountain landscape",
  "mediaType": "images",
  "maxResults": 50
}
```

**Mode 2: commercial-safe, CC0-only audio**

```json
{
  "query": "piano",
  "mediaType": "audio",
  "license": "cc0",
  "licenseType": "commercial",
  "maxResults": 20
}
```

**Mode 3: filtered by source, modification allowed**

```json
{
  "query": "vintage car",
  "mediaType": "images",
  "source": "flickr",
  "licenseType": "modification",
  "maxResults": 100
}
```

### Output sample

Real output from a search for `"mountain landscape"`:

```json
{
  "id": "8c85412a-6d6d-4d42-b0d9-2d04867ab31b",
  "title": "Mountains landscape 1",
  "creator": "Joeri van Veen",
  "creatorUrl": "https://www.flickr.com/photos/47173113@N00",
  "license": "by-nc-nd",
  "licenseVersion": "2.0",
  "licenseUrl": "https://creativecommons.org/licenses/by-nc-nd/2.0/",
  "attribution": "\"Mountains landscape 1\" by Joeri van Veen is licensed under CC BY-NC-ND 2.0. To view a copy of this license, visit https://creativecommons.org/licenses/by-nc-nd/2.0/.",
  "provider": "flickr",
  "source": "flickr",
  "sourceUrl": "https://www.flickr.com/photos/47173113@N00/9127271170",
  "imageUrl": "https://live.staticflickr.com/5457/9127271170_42c133847e_b.jpg",
  "height": 737,
  "width": 1024,
  "query": "mountain landscape"
}
```

A real audio result from a search for `"piano"` with `license=cc0`:

```json
{
  "id": "0eb636a7-2bc4-483e-8ae6-52a97374cfc1",
  "title": "Piano C.wav",
  "creator": "pinkyfinger",
  "creatorUrl": "https://freesound.org/people/pinkyfinger",
  "license": "cc0",
  "licenseVersion": "1.0",
  "licenseUrl": "https://creativecommons.org/publicdomain/zero/1.0/",
  "attribution": "\"Piano C.wav\" by pinkyfinger is marked with CC0 1.0. To view the terms, visit https://creativecommons.org/publicdomain/zero/1.0/.",
  "provider": "freesound",
  "source": "freesound",
  "fileType": "mp3",
  "audioUrl": "https://cdn.freesound.org/previews/68/68441_871124-hq.mp3",
  "duration": 1540,
  "query": "piano"
}
```

### Key output fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | String | Openverse's unique identifier for the asset |
| `title` | String | Asset title as catalogued |
| `creator` / `creatorUrl` | String | Original creator's name and profile link, when known |
| `license` / `licenseVersion` | String | Creative Commons license code and version |
| `licenseUrl` | String | Direct link to the license text |
| `attribution` | String | Ready-to-paste attribution sentence |
| `provider` / `source` | String | Which platform hosts the original (Flickr, Wikimedia, Freesound, etc.) |
| `sourceUrl` | String | Link back to the original listing |
| `imageUrl` (images) | String | Direct file URL |
| `height` / `width` (images) | Number | Dimensions in pixels |
| `audioUrl` (audio) | String | Direct file URL |
| `duration` (audio) | Number | Length in milliseconds |
| `query` | String | The search query that produced this record |

### Pricing

| Event | Price |
|-------|-------|
| Result returned | $0.0005 |

Pay-per-result, no separate actor-start charge. A 1,000-result batch costs
$0.50; the default 50-result run costs $0.025.

### What makes this richer than the competition

Several other publishers wrap the same Openverse API:

- **crawlerbros/pixabay-scraper** charges $0.005 per actor start plus
  $0.005 per result on the Free tier, 10x this actor's per-result price.
- **fortuitous_pirate/openverse-scraper** charges $0.0125 per result plus
  a $0.001 start fee, 25x this actor's price.
- **scrapers_lat/openverse-cc-media-scraper** charges $0.0088 per result
  across every subscription tier, about 17x this actor's price.

This actor charges a flat $0.0005 per result with no separate start fee,
by a wide margin the cheapest Openverse wrapper in the Store, while still
returning full license, attribution and provider detail plus the same
license, license-type and source filters the pricier competitors offer.

### Notes & limitations

- Results depend entirely on what Openverse itself has indexed; this
  actor does not search any site Openverse does not already cover.
- `creator`, `creatorUrl` and some dimension fields come back empty when
  the original source did not supply them to Openverse; the actor never
  fills in a guess.
- The `license` and `source` filters only narrow results to values
  Openverse itself recognizes; an unsupported code returns zero results
  rather than an error.
- Always use the `attribution` field as provided rather than writing your
  own credit line: some licenses (by-nc, by-nd, by-sa) carry restrictions
  beyond plain attribution, and copying the generated text keeps the
  usage compliant.

### FAQ

**Do I need an Openverse or API key account?**
No, Openverse's search is public and free; the actor needs no credential
from you.

**Can I get only assets that allow commercial use?**
Yes, set `licenseType` to `"commercial"`.

**Can I get only public-domain assets with no attribution required?**
Yes, set `license` to `"cc0"` (public domain) or `"pdm"` (public domain
mark).

**Why are some results missing a thumbnail or dimensions?**
Because the original source did not provide that field to Openverse. The
actor never invents a value for a missing field.

**Can I restrict results to one provider, like just Wikimedia?**
Yes, set `source` to the provider name, e.g. `"wikimedia"`.

**Is the attribution text legally sufficient on its own?**
For most CC licenses, yes, pasting the `attribution` field as given meets
the attribution requirement; always check the specific license (via
`licenseUrl`) if you plan heavy commercial use.

### For AI Agents & LLM Apps

This actor is callable from any MCP-compatible AI assistant through the
[Apify MCP server](https://mcp.apify.com), and directly from code through
the Apify API.

**Via MCP** (`mcp.apify.com`): add the Apify MCP server to your AI
assistant (Claude, ChatGPT, or any MCP client) and call the
`gio21/creative-commons-scraper` actor by name with a `query`. The
assistant gets back structured JSON, including ready-to-use attribution
text, it can reason over directly.

**Via API** (`run-sync-get-dataset-items`), for a synchronous call that
returns the dataset items in the same request:

```bash
curl "https://api.apify.com/v2/acts/gio21~creative-commons-scraper/run-sync-get-dataset-items?token=<APIFY_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"query": "mountain landscape", "mediaType": "images", "maxResults": 50}'
```

### Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by,
or sponsored by Openverse, Creative Commons, or any of the content
sources it indexes (Flickr, Wikimedia, Freesound, etc.). All trademarks
mentioned are the property of their respective owners.

### SEO Keywords

creative commons scraper, openverse scraper, free images api, cc0 images scraper, royalty free image search, creative commons audio scraper, free stock photo scraper

# Actor input Schema

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

What to search for.

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

images or audio

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

Comma-separated CC licenses (cc0, pdm, by, by-sa, by-nc, by-nd). Leave empty for all.

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

commercial, modification, or empty.

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

Filter by source (flickr, wikimedia, rawpixel, etc.).

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

Cap on total records returned. Default 100.

## Actor input object example

```json
{
  "query": "mountain landscape",
  "mediaType": "images",
  "maxResults": 50
}
```

# Actor output Schema

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

Scraped records.

# 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 landscape"
};

// Run the Actor and wait for it to finish
const run = await client.actor("gio21/creative-commons-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 landscape" }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gio21/creative-commons-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/9Tn4nTq6J6pbvcXPd/builds/W1Ai6tCPLfe86Xq4u/openapi.json