# Pexels Stock Media Scraper (`nimbryxo-studio/pexels-stock-media-scraper-2`) Actor

Scrape free stock photos and videos from Pexels. Search by keyword, browse curated/popular media, a photographer's portfolio, or a curated collection. Get direct image and video file URLs, photographer credit, tags, colors, and more.

- **URL**: https://apify.com/nimbryxo-studio/pexels-stock-media-scraper-2.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Automation, Developer tools, Videos
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Pexels Stock Media Scraper

Scrape **Pexels** photos and videos without a Pexels account, cookie, or API key. Search by keyword, browse the curated feed, pull a photographer's portfolio or a collection, look up exact photos and videos by ID or URL, find similar media, or paste any Pexels link. Get direct CDN URLs at every size and video rendition, tags, colors, dimensions, photographer credit, engagement counts, camera metadata, and the full photographer profile.

### What this actor does

- **Seven ways in:** `search`, `curated`, `byMediaId`, `byUser`, `byCollection`, `similarMedia`, `byUrl`
- **Photos and videos in one actor:** search one type or both, and mix photo/video IDs and URLs
- **Full filter surface:** orientation, size, color or hex, people count, people age, locale, minimum width/height, minimum FPS, duration range, and publish-date window
- **Direct media URLs:** multiple image sizes, the original file, every video rendition, and a highest-resolution convenience URL
- **Photographer credit:** name, profile, avatar, location, socials, donation link, hero/superhero badges, and full profile statistics
- **Engagement and camera data:** views, downloads, likes, image views, reactions, EXIF camera fields, content-safety ratings, and file size when `includeDetails` is on
- **Empty fields are omitted:** you never have to defend against `null`
- **No browser:** the actor uses Pexels' public web JSON route with an HTML fallback, so runs are small and fast

### Modes

| Mode | What you give it | What you get |
|---|---|---|
| `search` | `searchQueries` + `mediaType` | Keyword results, photos, videos, or both |
| `curated` | nothing | Pexels' editorial photo feed (paginated) |
| `byMediaId` | `mediaIds` | Exact photos and videos by ID or URL, enriched with detail data |
| `byUser` | `username` | A photographer's full portfolio, with profile stats |
| `byCollection` | `collectionSlug` | Every photo and video in a collection |
| `similarMedia` | `mediaIds` | Pexels' related-media feed for each seed |
| `byUrl` | `startUrls` | Automatically routes search, photo, video, profile, collection, image, and video-file URLs |

Legacy mode values are still accepted in code: `byPhotoId` maps to `byMediaId` and `similarPhotos` maps to `similarMedia`. The old `searchQuery` and `photoIds` input keys are mapped too, so saved tasks keep working.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `curated` / `byMediaId` / `byUser` / `byCollection` / `similarMedia` / `byUrl` |
| `searchQueries` | array | `[]` | One or more keywords for search |
| `mediaType` | string | `photos` | `photos` / `videos` / `all` |
| `startUrls` | array | `[]` | Pexels URLs for `byUrl` |
| `orientation` | string | `all` | `all` / `landscape` / `portrait` / `square` |
| `size` | string | `all` | `all` / `large` (24 MP or 4K) / `medium` (12 MP or Full HD) / `small` (4 MP or HD) |
| `color` | string | `all` | 12 Pexels colors, photos only |
| `colorHex` | string | empty | Any hex color such as `#2563eb`; overrides `color` |
| `peopleCount` | string | `all` | `all` / `0` / `1` / `2` |
| `peopleAge` | string | `all` | `all` / `baby` / `child` / `teenager` / `adult` |
| `locale` | string | `en-US` | 28 Pexels locales; localizes titles, descriptions, and search |
| `minWidth` | integer | `0` | Minimum width in pixels (0 = off) |
| `minHeight` | integer | `0` | Minimum height in pixels (0 = off) |
| `minFps` | integer | `0` | Minimum video frame rate (0 = off); photos always pass |
| `minDuration` | integer | `0` | Minimum video duration in seconds (0 = off) |
| `maxDuration` | integer | `0` | Maximum video duration in seconds (0 = off) |
| `publishedAfter` | string | empty | `YYYY-MM-DD`; keep media published on or after this date |
| `publishedBefore` | string | empty | `YYYY-MM-DD`; keep media published on or before this date |
| `mediaIds` | array | `[]` | Photo/video IDs or URLs for ID and similar modes |
| `username` | string | empty | Photographer handle, ID, or profile URL |
| `collectionSlug` | string | empty | Collection slug or full URL |
| `maxItems` | integer | `30` | Global cap (1-5000); prefill 3 for the daily test |
| `includeDetails` | boolean | `false` | Add views/downloads/likes, EXIF, content safety, and full profile stats; one extra request per item |
| `dedupe` | boolean | `true` | Keep only the first occurrence of each media ID |
| `proxyConfiguration` | object | off | Optional proxy override; the actor works directly and escalates only when blocked |

### Examples

Search landscape nature photos at least 24 MP:

```json
{
  "mode": "search",
  "searchQueries": ["nature"],
  "mediaType": "photos",
  "orientation": "landscape",
  "size": "large",
  "maxItems": 50
}
```

Search short ocean videos at 60 fps or higher:

```json
{
  "mode": "search",
  "searchQueries": ["ocean"],
  "mediaType": "videos",
  "minFps": 60,
  "maxDuration": 30,
  "maxItems": 20
}
```

Get a photographer's portfolio in Spanish:

```json
{
  "mode": "byUser",
  "username": "alex-ivanov-773258579",
  "locale": "es-ES",
  "maxItems": 100
}
```

Look up a photo and a video by ID:

```json
{
  "mode": "byMediaId",
  "mediaIds": ["18872916", "25961000"]
}
```

Scrape a collection, including its videos:

```json
{
  "mode": "byCollection",
  "collectionSlug": "fashion-kwvfk6o",
  "mediaType": "all",
  "maxItems": 100
}
```

Find media similar to a photo or video:

```json
{
  "mode": "similarMedia",
  "mediaIds": ["18872916"],
  "maxItems": 24
}
```

Paste any Pexels link:

```json
{
  "mode": "byUrl",
  "startUrls": [
    {"url": "https://www.pexels.com/search/nature/?orientation=landscape"},
    {"url": "https://www.pexels.com/photo/18872916/"},
    {"url": "https://www.pexels.com/@alex-ivanov-773258579/"},
    {"url": "https://www.pexels.com/collections/aquatic-aesthetic-bw7dkse/"}
  ],
  "maxItems": 60
}
```

### Output

Every row is one photo or video. Existing field names are preserved.

#### Photo fields

`photoId`, `title`, `description`, `alt`, `slug`, `width`, `height`, `orientation`, `aspectRatio`, `license`, `licenseUrl`, `featured`, `createdAt`, `publishedAt`, `updatedAt`, `feedAt`, `photographerName`, `photographerId`, `photographerUsername`, `photographerUrl`, `photographerAvatarUrl`, `photographerLocation`, `photographerInstagram`, `photographerTwitter`, `photographerIsHero`, `photographerSuperhero`, `photographerActiveHero`, `photographerBadges`, `photographerDonateUrl`, `attribution`, `tags`, `imageSmallUrl`, `imageMediumUrl`, `imageLargeUrl`, `imageOriginalUrl`, `downloadUrl`, `downloadPageUrl`, `avgColor`, `colorPalette`, `collectionIds`, `reactionEmotionalCount`, `reactionTechnicalCount`, `reactionStylisticCount`, `pageUrl`, `sourceUrl`, `recordType`, `scrapedAt`.

With `includeDetails` or `byMediaId`, photos can also include `cameraMake`, `cameraModel`, `cameraIso`, `cameraAperture`, `cameraFocalLength`, `cameraShutterSpeed`, `cameraSoftware`, `photographedAt`, `cameraOrientation`, `fileSizeBytes`, `latitude`, `longitude`, `locationName`, `copyright`, `googlePlaceId`, `contentSafety`, `viewsCount`, `downloadsCount`, `likesCount`, `imageViewsCount`, and the full profile fields below.

#### Video fields

`videoId`, `title`, `description`, `slug`, `width`, `height`, `orientation`, `aspectRatio`, `durationSeconds`, `fps`, `license`, `licenseUrl`, `featured`, `createdAt`, `publishedAt`, `updatedAt`, `feedAt`, `photographerName`, `photographerId`, `photographerUsername`, `photographerUrl`, `photographerAvatarUrl`, `photographerLocation`, `photographerInstagram`, `photographerTwitter`, `photographerIsHero`, `photographerSuperhero`, `photographerActiveHero`, `photographerBadges`, `photographerDonateUrl`, `attribution`, `tags`, `videoPreviewUrl`, `videoProvider`, `thumbnailSmallUrl`, `thumbnailMediumUrl`, `thumbnailLargeUrl`, `downloadUrl`, `downloadPageUrl`, `videoFiles[]`, `bestVideoUrl`, `collectionIds`, `reactionEmotionalCount`, `reactionTechnicalCount`, `reactionStylisticCount`, `pageUrl`, `sourceUrl`, `recordType`, `scrapedAt`.

`videoFiles[]` entries contain `url`, `quality` (when Pexels supplies it), `width`, `height`, `fps`, `fileType`, and `downloadUrl`. There is no top-level `videoQuality` field; the quality label lives inside each `videoFiles[]` entry.

#### Profile fields (detail / portfolio modes)

`photographerBio`, `photographerWebsite`, `photographerYoutube`, `photographerTiktok`, `photographerFollowersCount`, `photographerFollowingsCount`, `photographerPhotosCount`, `photographerMediaCount`, `photographerPortfolioMediaCount`, `photographerCollectionsCount`, `photographerFirstUploadedOn`, `photographerLastUploadedAt`, `photographerImageViewsAllTime`, `photographerImageViewsLast30Days`, `photographerChallengesWonCount`, `photographerChallengesParticipatedCount`, `photographerHomepageFeaturedCount`, `photographerLeaderboardLast30DaysPosition`, `photographerLeaderboardAllTimePosition`, `photographerConfirmed`, `photographerBadges[]`.

#### Provenance

`foundBy` is one of `keyword`, `curated`, `id`, `user`, `collection`, or `similar`; `query`, `seedMediaId`, `collectionSlug`, and `username` are added where they apply. `sourceUrl` remains the media page URL for backward compatibility.

### Limits and data notes

- **Search depth:** Pexels serves at most about **480 records per search query** (20 pages of 24). Page 21 and beyond return empty even though the site displays `total_results=10000`. Use narrower queries, filters, multiple queries, or the curated/profile/collection modes for more.
- **Curated feed:** photos only. The public feed contains about **68,000 curated photos** and paginates at 80 per page.
- **Photographer, collection, and similar feeds:** 80 records per page and paginate to the source total. The HTML fallback is limited to its first 12 records because `?page=N` is ignored on those pages; the actor uses the public web JSON route for full pagination.
- **Video by ID:** Pexels returns 403 for a bare numeric video URL without a locale prefix; the actor resolves video IDs through the media JSON route first, then falls back to the locale-prefixed video page (`/{locale}/video/<id>/`) and its detail data.
- **Server-side filters:** orientation, size, color/hex, people count, people age, locale, and video resolution/frame-rate parameters are honored. Duration, width, height, and publish-date filters are applied by the actor on the returned records because Pexels' web route ignores them.
- **Camera and location fields are conditional:** in a 10-photo sample, camera data was present on 50%, a location name on 20%, and latitude/longitude on 0%. A later 50-photo audit found camera and location text on 26-60% of records but no coordinates. Empty fields are omitted, never fabricated.
- **Coordinates and collection membership are not public:** the anonymous Pexels route exposes `mediumDetails` latitude/longitude as null and returns an empty `collection_ids` array. The actor keeps `latitude`, `longitude`, and `collectionIds` for compatibility but omits them when Pexels does not provide values.
- **Image originals:** most originals are JPEG, but some are PNG. The actor takes the original URL from Pexels' own download link instead of assuming an extension.
- **Attribution:** Pexels asks API users to credit photographers and link back to Pexels. The actor adds a ready-to-use `attribution` field and `licenseUrl` to every record. The Pexels license itself does not require attribution.
- **No account, cookie, or API key:** all data comes from public Pexels pages and Pexels' public browser route. The actor keeps an HTML fallback if the public route changes.
- **Proxy:** direct connections are the default. The actor escalates automatically only if Pexels blocks the run. The optional `proxyConfiguration` field is an override, not a requirement.

### Use cases

- Content and social teams sourcing campaign imagery and clips
- Designers building moodboards and placeholders at specific sizes and orientations
- Video editors finding 4K/60 fps clips by duration
- AI and ML teams building tagged image/video datasets with dimensions, colors, and engagement signals
- Digital asset teams mirroring direct CDN URLs into a DAM with photographer credit and license traceability
- Localization teams pulling the same query in multiple languages

### FAQ

**Is this affiliated with Pexels?**
No. This is an independent third-party actor that reads public Pexels pages. It is not affiliated with or endorsed by Pexels.

**Do I need a Pexels account or API key?**
No. The actor does not use the official Pexels API, so there is no account, API key, quota, or cookie to supply.

**Are the media files free to use?**
Pexels publishes its content under the Pexels License, which allows free personal and commercial use without attribution. Review the current license and the context of each asset before publishing. The actor returns `licenseUrl` and `attribution` to make credit easy.

**Why do some records miss camera or location fields?**
Those values come from the original upload and the photographer's profile. Pexels only retains them when they were supplied. The actor omits unavailable fields instead of returning an empty column.

**Why did `search` stop at about 480 records?**
That is Pexels' anonymous search ceiling. Split the topic into narrower queries or use `curated`, `byUser`, `byCollection`, or `similarMedia`, which paginate to larger totals.

**Why does a collection return 84 records when I asked for 100?**
The collection itself has 84 records. `maxItems` is a cap, not a guarantee that the source contains that many matches.

**Can I get videos in a collection or portfolio?**
Yes. Set `mediaType` to `videos` or `all`. Collection media type filtering is applied by the actor; portfolio media type is also filtered server-side.

**What is `includeDetails`?**
It opens each media's detail page to add views, downloads, likes, camera/EXIF data, content safety, and full profile stats. It costs one extra request per item. `byMediaId` always enriches because exact lookup is expected to return the complete record.

**Can I paste a normal Pexels URL?**
Yes. `byUrl` accepts search pages (with their filters), photo pages, video pages, photographer profiles, collections, image-file URLs, and video-file URLs.

**Are the CDN links stable?**
All tested `images.pexels.com` and `videos.pexels.com` links returned 200. The actor returns the URLs exactly as Pexels supplies them, including the original file and every video rendition. Keep the media ID as the stable key.

**How fresh is the data?**
Every run reads Pexels live, so engagement counts and search order reflect the moment of the run.

# Actor input Schema

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

What to fetch from Pexels. Use Search by keyword for discovery, Look up media by ID/URL for exact assets, Photographer portfolio or Collection for a catalog, Similar media for related assets, Curated feed for Pexels' editorial selection, or Paste URLs to route any Pexels link automatically.

## `searchQueries` (type: `array`):

One or more keywords for mode=search, one per line. Each query is searched separately and duplicates are removed. Example: `nature`, `city skyline`, `coffee`.

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

Photos, videos, or both. `all` searches photos and videos and merges the results. Exact ID/URL lookups return the requested media type regardless of this setting.

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

Pexels search, photo, video, photographer, collection, image-file, or video-file URLs for mode=byUrl. Search URLs keep their orientation, size, color, people, and page filters.

## `orientation` (type: `string`):

Filter by media orientation. Applies to search, profile, and collection modes.

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

Pexels minimum-size filter. Photos: large is 24 MP, medium is 12 MP, small is 4 MP. Videos: large is 4K, medium is Full HD, small is HD.

## `color` (type: `string`):

Filter photos by dominant color. Use Color hex instead for an exact hex value. Photos only.

## `colorHex` (type: `string`):

Optional hex color such as `#2563eb` or `#fff`. Overrides the Color dropdown when set. Photos only.

## `peopleCount` (type: `string`):

Filter by how many people appear in the media. Applies to photos and videos.

## `peopleAge` (type: `string`):

Filter by the age of people in the media. Applies to photos and videos.

## `locale` (type: `string`):

Pexels locale for titles, descriptions, and search results. Search terms are used as typed.

## `minWidth` (type: `integer`):

Only return media at least this wide. 0 disables the filter. Enforced on each returned record.

## `minHeight` (type: `integer`):

Only return media at least this tall. 0 disables the filter. Enforced on each returned record.

## `minFps` (type: `integer`):

Only return videos with at least this many frames per second (for example 60). 0 disables the filter. Photos always pass.

## `minDuration` (type: `integer`):

Only return videos at least this many seconds long. 0 disables the filter.

## `maxDuration` (type: `integer`):

Only return videos at most this many seconds long. 0 disables the filter.

## `publishedAfter` (type: `string`):

Optional YYYY-MM-DD date. Only return media published on or after this date. Applied to the records returned by the current search/all listing.

## `publishedBefore` (type: `string`):

Optional YYYY-MM-DD date. Only return media published on or before this date. Applied to the records returned by the current search/all listing.

## `mediaIds` (type: `array`):

Pexels photo or video IDs, or full photo/video/image-file URLs. Used by Look up media by ID/URL and Similar media modes.

## `username` (type: `string`):

Pexels photographer handle, ID, or profile URL for mode=byUser. Example: `alex-ivanov-773258579` or `https://www.pexels.com/@alex-ivanov-773258579/`.

## `collectionSlug` (type: `string`):

Pexels collection slug or full collection URL for mode=byCollection. Example: `aquatic-aesthetic-bw7dkse`.

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

Maximum number of media records to return across all queries, IDs, and URLs. Pexels search serves at most about 480 records per query (20 pages of 24); a single search query cannot exceed that even with a higher value.

## `includeDetails` (type: `boolean`):

Open each media's detail page to add views, downloads, likes, camera/EXIF data, and the photographer's full profile. Adds one request per item and can be slow on large runs. Mode=byMediaId always enriches.

## `dedupe` (type: `boolean`):

Keep only the first occurrence of each photo or video across queries, IDs, and URLs.

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

Optional Apify proxy override. The actor works directly without a proxy and escalates automatically only if Pexels blocks the run.

## Actor input object example

```json
{
  "mode": "search",
  "searchQueries": [
    "nature"
  ],
  "mediaType": "photos",
  "startUrls": [],
  "orientation": "all",
  "size": "all",
  "color": "all",
  "colorHex": "",
  "peopleCount": "all",
  "peopleAge": "all",
  "locale": "en-US",
  "minWidth": 0,
  "minHeight": 0,
  "minFps": 0,
  "minDuration": 0,
  "maxDuration": 0,
  "publishedAfter": "",
  "publishedBefore": "",
  "mediaIds": [
    "18872916"
  ],
  "username": "alex-ivanov-773258579",
  "collectionSlug": "aquatic-aesthetic-bw7dkse",
  "maxItems": 3,
  "includeDetails": false,
  "dedupe": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `media` (type: `string`):

Dataset containing all scraped Pexels photos and videos.

# 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 = {
    "mode": "search",
    "searchQueries": [
        "nature"
    ],
    "mediaType": "photos",
    "orientation": "all",
    "size": "all",
    "color": "all",
    "colorHex": "",
    "peopleCount": "all",
    "peopleAge": "all",
    "locale": "en-US",
    "minWidth": 0,
    "minHeight": 0,
    "minFps": 0,
    "minDuration": 0,
    "maxDuration": 0,
    "publishedAfter": "",
    "publishedBefore": "",
    "mediaIds": [
        "18872916"
    ],
    "username": "alex-ivanov-773258579",
    "collectionSlug": "aquatic-aesthetic-bw7dkse",
    "maxItems": 3,
    "includeDetails": false,
    "dedupe": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/pexels-stock-media-scraper-2").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 = {
    "mode": "search",
    "searchQueries": ["nature"],
    "mediaType": "photos",
    "orientation": "all",
    "size": "all",
    "color": "all",
    "colorHex": "",
    "peopleCount": "all",
    "peopleAge": "all",
    "locale": "en-US",
    "minWidth": 0,
    "minHeight": 0,
    "minFps": 0,
    "minDuration": 0,
    "maxDuration": 0,
    "publishedAfter": "",
    "publishedBefore": "",
    "mediaIds": ["18872916"],
    "username": "alex-ivanov-773258579",
    "collectionSlug": "aquatic-aesthetic-bw7dkse",
    "maxItems": 3,
    "includeDetails": False,
    "dedupe": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/pexels-stock-media-scraper-2").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 '{
  "mode": "search",
  "searchQueries": [
    "nature"
  ],
  "mediaType": "photos",
  "orientation": "all",
  "size": "all",
  "color": "all",
  "colorHex": "",
  "peopleCount": "all",
  "peopleAge": "all",
  "locale": "en-US",
  "minWidth": 0,
  "minHeight": 0,
  "minFps": 0,
  "minDuration": 0,
  "maxDuration": 0,
  "publishedAfter": "",
  "publishedBefore": "",
  "mediaIds": [
    "18872916"
  ],
  "username": "alex-ivanov-773258579",
  "collectionSlug": "aquatic-aesthetic-bw7dkse",
  "maxItems": 3,
  "includeDetails": false,
  "dedupe": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call nimbryxo-studio/pexels-stock-media-scraper-2 --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/pexels-stock-media-scraper-2"
        }
    }
}
```

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/b6anw2Kxq3xyPpgNC/builds/rSmmuRgL2b2u0iqFa/openapi.json