# Openverse Scraper — CC Images, Audio & Media API (`logiover/openverse-scraper`) Actor

Scrape Openverse by keyword, license, or media ID. Extract title, creator, license, URL, thumbnail, tags, dimensions for stock research, dataset building, and CC media discovery. No API key, no login.

- **URL**: https://apify.com/logiover/openverse-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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

## Openverse Scraper — CC Images, Audio & Media API

Scrape Creative Commons images and audio from [Openverse](https://openverse.org/) by keyword, license type, or media ID. Extract full metadata for stock research, AI training datasets, and CC media discovery — no API key required.

### What does Openverse Scraper do?

Openverse Scraper connects to the official [Openverse API](https://api.openverse.org/v1/) — the world's largest catalog of openly licensed media, covering over 600 million Creative Commons images and audio tracks from sources like Flickr, Wikimedia Commons, Rawpixel, Jamendo, and more. The actor performs keyless anonymous queries against the `/images/` and `/audio/` search endpoints, paginates through results in batches of 100, and pushes clean structured records to Apify's dataset storage.

Three modes are available: **images** (keyword search across CC photographs, illustrations, and vectors), **audio** (keyword search across CC music, recordings, and sound effects), and **detail** (fetch full metadata for a single image by its UUID). Optional filters let you narrow results by license type (CC BY, CC0, CC BY-SA, etc.) or by source provider (flickr, wikimedia, rawpixel). The actor respects Openverse's anonymous rate limits with low concurrency and polite delays, ensuring stable long-running jobs that can yield thousands of items per query.

### Who is it for?

- **Designers and content creators** who need free-to-use images or audio for commercial and personal projects
- **AI/ML researchers** building training datasets of openly licensed visual or audio content
- **Journalists and educators** who need properly attributed CC media for publications
- **Stock media analysts** researching licensing trends, provider coverage, and keyword availability on open platforms
- **Developers and data engineers** who need bulk CC media metadata for cataloging, recommendation systems, or archival projects

### Use cases

- Build a curated CC image dataset for computer vision model training (e.g., all CC0 landscape photos from Wikimedia)
- Monitor which keywords return the most results on Openverse to guide content creation strategy
- Automatically generate properly attributed image galleries for a CMS or editorial platform
- Research the distribution of CC license types (BY, BY-SA, BY-NC, etc.) across major media sources
- Discover ambient music and sound effects under CC licenses for podcast or video production

### Why use Openverse Scraper?

- **No API key required** — anonymous access to the full Openverse catalog, no registration needed
- **15 structured fields per item** — ID, title, creator, license, version, URL, thumbnail, source page, provider, tags, file type, dimensions, and attribution text
- **Bulk pagination** — paginate up to 10,000 results per query automatically
- **Three modes** — images search, audio search, single-item detail fetch
- **License and source filters** — narrow to CC0 only, or to a specific source like Flickr or Wikimedia
- **Export CSV, JSON, Excel** — download results in any format via Apify dataset interface or API
- **Pay-per-result pricing** — only pay for the data you actually collect

### What data can you extract?

The actor extracts the following fields for every media item:

| Field | Type | Description |
|-------|------|-------------|
| id | string | Openverse UUID for the media item |
| title | string | Title or filename of the media |
| creator | string | Author/photographer/artist name |
| license | string | CC license slug (e.g. `by`, `by-sa`, `cc0`) |
| licenseVersion | string | License version (e.g. `2.0`, `4.0`) |
| url | string | Direct URL to the media file |
| thumbnail | string | Openverse-hosted thumbnail URL |
| foreignLandingUrl | string | Original source page URL (e.g. Flickr page) |
| source | string | Source name (e.g. `flickr`, `wikimedia`) |
| provider | string | Provider name (usually same as source) |
| tags | string | Comma-separated tag list |
| fileType | string | File extension (jpg, png, mp3, etc.) |
| width | string | Image width in pixels (images only) |
| height | string | Image height in pixels (images only) |
| attribution | string | Full pre-formatted attribution sentence |

**Example output:**

```json
{
  "id": "8dac0234-5511-43f8-bcc7-0c6c0c41c83d",
  "title": "Mountain landscape",
  "creator": "randihausken",
  "license": "by-sa",
  "licenseVersion": "2.0",
  "url": "https://live.staticflickr.com/6083/6036144711_e2c3f202c5_b.jpg",
  "thumbnail": "https://api.openverse.org/v1/images/8dac0234-5511-43f8-bcc7-0c6c0c41c83d/thumb/",
  "foreignLandingUrl": "https://www.flickr.com/photos/46406832@N00/6036144711",
  "source": "flickr",
  "provider": "flickr",
  "tags": "landscape, mountains, telemark",
  "fileType": null,
  "width": "1024",
  "height": "682",
  "attribution": "\"Mountain landscape\" by randihausken is licensed under CC BY-SA 2.0. To view a copy of this license, visit https://creativecommons.org/licenses/by-sa/2.0/."
}
````

### How to use

#### Option A — Search by keyword (images or audio)

Set `mode` to `images` or `audio`, provide a `query`, optionally add `license` and `source` filters, and set `maxResults` for volume control.

```json
{
  "mode": "images",
  "query": "ocean sunset",
  "license": "by",
  "source": "flickr",
  "maxResults": 500,
  "proxyConfig": { "useApifyProxy": true }
}
```

#### Option B — Fetch a single image by ID (detail mode)

Set `mode` to `detail` and provide the Openverse image UUID as `imageId`.

```json
{
  "mode": "detail",
  "imageId": "8dac0234-5511-43f8-bcc7-0c6c0c41c83d",
  "proxyConfig": { "useApifyProxy": true }
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| mode | string | `images` | Scraping mode: `images`, `audio`, or `detail` |
| query | string | — | Search keyword(s) for images or audio mode |
| imageId | string | — | Image UUID for detail mode |
| license | string | — | CC license filter (e.g. `by`, `cc0`, `by-sa`) |
| source | string | — | Source filter (e.g. `flickr`, `wikimedia`) |
| maxResults | integer | 200 | Maximum items to return (up to 10,000) |
| proxyConfig | object | Apify proxy | Proxy configuration |

**Full input example:**

```json
{
  "mode": "images",
  "query": "jazz music",
  "license": "cc0",
  "source": "",
  "maxResults": 1000,
  "proxyConfig": { "useApifyProxy": true }
}
```

### Output example

```json
{
  "id": "041a3c2b-76e8-40cc-b10e-f91a53972be6",
  "title": "Denali - Mountain Landscape from Alaska",
  "creator": "blmiers2",
  "license": "by-nc-sa",
  "licenseVersion": "2.0",
  "url": "https://live.staticflickr.com/7191/6904758951_6868a06560_b.jpg",
  "thumbnail": "https://api.openverse.org/v1/images/041a3c2b-76e8-40cc-b10e-f91a53972be6/thumb/",
  "foreignLandingUrl": "https://www.flickr.com/photos/41304517@N00/6904758951",
  "source": "flickr",
  "provider": "flickr",
  "tags": "alaska, denali, glacier, ice, landscape, mountain, snow, travel, winter",
  "fileType": null,
  "width": "1024",
  "height": "683",
  "attribution": "\"Denali - Mountain Landscape from Alaska\" by blmiers2 is licensed under CC BY-NC-SA 2.0. To view a copy of this license, visit https://creativecommons.org/licenses/by-nc-sa/2.0/."
}
```

### Tips for best results

- **Use specific queries** — `"jazz piano new orleans"` returns more targeted results than just `"music"`
- **Filter by license type** — use `cc0` or `by` for maximum reusability in commercial projects
- **Combine source + license** — e.g. `source: wikimedia, license: cc0` for high-quality public domain images
- **Set maxResults to 1000+** — Openverse has millions of items; the actor handles pagination automatically
- **Audio mode** — try queries like `"ambient nature"`, `"jazz"`, or \`"electronic" for Jamendo music tracks
- **Detail mode for enrichment** — if you have a list of IDs from another source, use detail mode to fetch full metadata
- **Export to CSV** — use Apify's dataset download for spreadsheet-ready attribution lists
- **Rate limits** — the actor uses 500ms delays between pages to stay within anonymous limits; for higher volume, consider Openverse's registered API key (currently free)
- **Tag filtering** — download a large result set and filter by tags in Excel/Python for topical subsets
- **Schedule runs** — use Apify Scheduler to capture newly indexed CC media on a regular cadence

### Integrations

Openverse Scraper outputs clean JSON to Apify's dataset storage, which integrates with:

- **Google Sheets** — connect via Apify's Google Sheets integration or export CSV
- **Slack** — receive notifications when a run completes via Apify Webhooks → Slack
- **Zapier / Make** — trigger workflows from new Openverse dataset items
- **Webhooks** — configure HTTP callbacks on run completion in Apify Console
- **Scheduled runs** — set up daily or weekly keyword monitoring via Apify Scheduler

### API usage

**cURL:**

```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~openverse-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"images","query":"mountain landscape","maxResults":200}'
```

**Node.js (Apify client):**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('logiover~openverse-scraper').call({
  mode: 'images',
  query: 'mountain landscape',
  maxResults: 200,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("logiover~openverse-scraper").call(run_input={
    "mode": "images",
    "query": "mountain landscape",
    "maxResults": 200,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["license"], item["url"])
```

### Use with AI agents (MCP)

Openverse Scraper is available as a tool via the Apify MCP server. Connect Claude, GPT-4o, or any MCP-compatible AI agent and instruct it: *"Find 500 CC BY-licensed images of ocean sunsets from Flickr and export them with their attribution text."* The agent will invoke this actor, paginate the results, and return structured data ready for use in content pipelines, dataset curation, or automated attribution generation.

### FAQ

#### Does this actor require an API key?

No. Openverse offers anonymous access to its public API. This actor works out of the box without any registration or credentials.

#### How many results can I extract per run?

Openverse supports up to 10,000 results per query via pagination. Set `maxResults` up to 10,000. For broader coverage, run multiple queries with different keywords.

#### What media sources does Openverse index?

Openverse indexes over 600 million items from sources including Flickr, Wikimedia Commons, Rawpixel, Jamendo, ccMixter, Free Music Archive, and many more. The `source` filter lets you restrict to a specific provider.

#### Why are some fields null?

Some providers don't supply all metadata. `fileType`, `width`, and `height` may be null for items where the source doesn't expose this data. The `creator` field may be null for anonymous uploads.

#### What happens if a query returns zero results?

The actor logs a warning and exits cleanly with zero items. This can happen with very niche or misspelled queries, or if a license+source combination has no indexed content.

#### Can I export results to Excel or CSV?

Yes. Open your dataset in Apify Console and click **Export** → choose CSV, Excel, or JSON. The attribution column provides ready-to-paste CC attribution text.

#### How fast does the actor run?

The actor fetches 100 items per page with a 500ms delay between pages to respect anonymous rate limits. Fetching 200 items takes about 2-3 seconds; 1,000 items takes roughly 15-20 seconds.

#### What CC license types can I filter by?

Use any Openverse license slug: `by`, `by-sa`, `by-nc`, `by-nd`, `by-nc-sa`, `by-nc-nd`, `cc0`, `pdm`. Leave blank to return all license types.

#### Is the data legal to use?

All items in Openverse carry a Creative Commons or equivalent open license. The attribution field provides the required credit text. Always read the specific license terms for commercial vs. non-commercial use restrictions.

#### How often is Openverse updated?

Openverse re-indexes sources continuously. New Flickr uploads and Wikimedia uploads appear within days to weeks. Schedule this actor weekly to capture freshly indexed CC content.

#### Can I scrape audio in the same run as images?

No — each run handles one mode. Run the actor twice with `mode: images` and `mode: audio` for both media types in the same workflow.

#### What are the related actors?

- **Flickr Scraper** — direct Flickr photo search and user gallery scraping
- **Wikipedia Scraper** — extract article text, images, and metadata from Wikimedia
- **Bulk DNS Lookup** — for domain research alongside media asset discovery

### Is it legal?

Openverse indexes publicly available Creative Commons licensed content published by their respective authors under open licenses. This actor accesses the official Openverse public API in accordance with standard API usage practices. The output data carries existing CC license terms that must be respected when using the media. This actor does not circumvent any access controls or authentication. Users are responsible for complying with the specific Creative Commons license type (attribution, share-alike, non-commercial restrictions) of each item they use. See [Openverse Terms of Service](https://wordpress.org/openverse/) and [Creative Commons licenses](https://creativecommons.org/licenses/) for details.

### Related scrapers

- **[B2B Lead Scraper](https://apify.com/logiover/b2b-lead-scraper)** — find business contacts and company data by industry and country
- **[Bulk DNS Lookup](https://apify.com/logiover/bulk-dns-lookup)** — bulk domain and DNS record resolution
- **[Subdomain Finder](https://apify.com/logiover/subdomain-finder)** — enumerate subdomains for any domain using certificate transparency

# Actor input Schema

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

What to scrape. 'images' and 'audio' search or browse Openverse. 'detail' fetches a single image by its ID. Leave everything else blank to browse popular Creative Commons media.

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

Search keyword(s). Used in images and audio modes. Leave EMPTY to browse a broad default listing of Creative Commons media — no query required.

## `imageId` (type: `string`):

Openverse image UUID for detail mode only.

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

Filter by a specific Creative Commons license. Leave blank for all licenses.

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

Filter by how the media may be used. Leave blank for all.

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

Filter by the provider the media comes from. Leave blank for all providers.

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

Filter by file format. Image formats: jpg, png, gif, svg. Audio formats: mp3, ogg, flac, wav, mid. Leave blank for all.

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

Maximum number of items to return. Leave at the default for a fast browse; raise it to pull more. Openverse supports up to 10,000 per query.

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

Apify proxy settings. Openverse is a public API — the default (automatic) proxy works well, and the Actor falls back to a direct connection if a proxy request fails.

## Actor input object example

```json
{
  "mode": "images",
  "query": "mountain landscape",
  "imageId": "8dac0234-5511-43f8-bcc7-0c6c0c41c83d",
  "license": "",
  "licenseType": "",
  "source": "",
  "extension": "",
  "maxResults": 200,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/openverse-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 = { "proxyConfiguration": { "useApifyProxy": True } }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Openverse Scraper — CC Images, Audio & Media API",
        "description": "Scrape Openverse by keyword, license, or media ID. Extract title, creator, license, URL, thumbnail, tags, dimensions for stock research, dataset building, and CC media discovery. No API key, no login.",
        "version": "1.0",
        "x-build-id": "hylnjLZVB9c3J3PhR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~openverse-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-openverse-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/logiover~openverse-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-openverse-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/logiover~openverse-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-openverse-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": {
                    "mode": {
                        "title": "Media Type",
                        "enum": [
                            "images",
                            "audio",
                            "detail"
                        ],
                        "type": "string",
                        "description": "What to scrape. 'images' and 'audio' search or browse Openverse. 'detail' fetches a single image by its ID. Leave everything else blank to browse popular Creative Commons media.",
                        "default": "images"
                    },
                    "query": {
                        "title": "Search Query (optional)",
                        "type": "string",
                        "description": "Search keyword(s). Used in images and audio modes. Leave EMPTY to browse a broad default listing of Creative Commons media — no query required."
                    },
                    "imageId": {
                        "title": "Image ID (detail mode only)",
                        "type": "string",
                        "description": "Openverse image UUID for detail mode only."
                    },
                    "license": {
                        "title": "License Filter (optional)",
                        "enum": [
                            "",
                            "cc0",
                            "pdm",
                            "by",
                            "by-sa",
                            "by-nc",
                            "by-nd",
                            "by-nc-sa",
                            "by-nc-nd"
                        ],
                        "type": "string",
                        "description": "Filter by a specific Creative Commons license. Leave blank for all licenses.",
                        "default": ""
                    },
                    "licenseType": {
                        "title": "License Usage (optional)",
                        "enum": [
                            "",
                            "commercial",
                            "modification",
                            "all",
                            "all-cc"
                        ],
                        "type": "string",
                        "description": "Filter by how the media may be used. Leave blank for all.",
                        "default": ""
                    },
                    "source": {
                        "title": "Source / Provider (optional)",
                        "enum": [
                            "",
                            "flickr",
                            "wikimedia",
                            "stocksnap",
                            "rawpixel",
                            "wordpress",
                            "sketchfab",
                            "spacex",
                            "phylopic",
                            "nappy",
                            "smithsonian_national_museum_of_natural_history",
                            "smithsonian_american_art_museum",
                            "smithsonian_cooper_hewitt_museum",
                            "met",
                            "clevelandmuseum",
                            "brooklynmuseum",
                            "museumsvictoria",
                            "digitaltmuseum",
                            "geographorguk",
                            "iha",
                            "bio_diversity",
                            "jamendo",
                            "wikimedia_audio",
                            "freesound"
                        ],
                        "type": "string",
                        "description": "Filter by the provider the media comes from. Leave blank for all providers.",
                        "default": ""
                    },
                    "extension": {
                        "title": "File Extension (optional)",
                        "enum": [
                            "",
                            "jpg",
                            "png",
                            "gif",
                            "svg",
                            "mp3",
                            "ogg",
                            "flac",
                            "wav",
                            "mid"
                        ],
                        "type": "string",
                        "description": "Filter by file format. Image formats: jpg, png, gif, svg. Audio formats: mp3, ogg, flac, wav, mid. Leave blank for all.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of items to return. Leave at the default for a fast browse; raise it to pull more. Openverse supports up to 10,000 per query.",
                        "default": 200
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Openverse is a public API — the default (automatic) proxy works well, and the Actor falls back to a direct connection if a proxy request fails.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
