# Adobe Stock Scraper & API: Keywords, Downloads, Views (`quarra/adobe-stock-scraper`) Actor

Adobe Stock scraper for assets from keywords, search URLs, asset URLs, contributor portfolios or similar images: title, keywords, downloads, views, contributor, upload date, AI label, premium, size, previews. Photos, vectors, illustrations, videos, templates and 3D.

- **URL**: https://apify.com/quarra/adobe-stock-scraper.md
- **Developed by:** [Quarra Labs](https://apify.com/quarra) (community)
- **Categories:** SEO tools, AI
- **Stats:** 7 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 assets

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/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

## Adobe Stock Scraper & API: Keywords, Downloads, Views

Get Adobe Stock assets in bulk, without an account or API key: photos, illustrations, vectors, videos, templates and
3D. Give it keywords, an Adobe Stock search URL, asset URLs, contributors, or any image to find similar ones. Each
asset comes back with its full keyword list, its number of downloads and views, the contributor, the category, the
upload date, size, format, AI label and preview links. Export as JSON, CSV or Excel, or read it through the Apify API.

**$0.60 per 1,000 assets**, plus a small start fee per run. Assets that no longer exist, repeats and inputs that fail
are not charged.

### Quick start

1. Type keywords (or paste an Adobe Stock search URL) into **Search keywords or search URLs**, or paste asset links
   into **Asset URLs or IDs**.
2. Set **Max assets** and, if you want more than 100 per search, **Max results per search**.
3. Click **Start** and read the assets in the run's **Output** tab.

Like any Apify Actor, it can also be run and read through the Apify API, scheduled, and connected to webhooks, Make,
Zapier, n8n or Apify's MCP server for AI agents.

### What it is used for

- **Keyword research for contributors**: the keywords the best-selling assets of a topic use, and how many downloads
  they have.
- **Demand by niche**: downloads and upload dates across a topic, a content type or the last month's uploads.
- **Contributor portfolios**: everything a contributor has online, with downloads per asset.
- **Tracking your own assets**: downloads and views of a list of asset IDs, run after run.

### What you get

| | |
|---|---|
| Asset ID, URL, title, type (photo, illustration, vector, video, template, 3D) | yes |
| Keywords and their number | yes |
| Downloads and views, as counted by Adobe Stock | yes |
| Contributor: name, ID, portfolio URL, country | yes |
| Category, its ID and full path | yes |
| Upload date | yes |
| Generative AI label, premium collection, model release | yes |
| Width, height, orientation, file format, file size | yes |
| Videos: duration, frame rate, preview video links | yes |
| Thumbnails (500 and 1,000 px) and the watermarked preview | yes |
| Position in the search | yes, when it comes from a search |

Measured on 8,817 assets (12/10/2026): keywords on 99.9 %, downloads on 99.3 %, contributor country on 99.9 %,
category on 96.4 %.

### Inputs

- **Search keywords or search URLs**: `coffee shop`, or a search URL copied from stock.adobe.com, in any language (its
  keywords, language, sort and filters are kept; the run summary names any filter that could not be applied).
- **Asset URLs or IDs**: `https://stock.adobe.com/images/barista-making-coffee/300428267`, any language and asset
  type, or just `300428267`. Thumbnail links (`ftcdn.net`) are read too. Up to 100,000 per run.
- **Contributors**: `https://stock.adobe.com/contributor/206684585/…` or `206684585`: their portfolio.
- **Similar to**: an Adobe Stock asset URL or ID, or a direct link to a JPEG or PNG image on the web: visually
  similar Adobe Stock assets.
- Up to 5,000 searches, contributors and similar-to inputs per run.
- **Max assets**: total assets the run delivers, counted exactly. **Max results per search**: up to 10,000.
- **Sort**: relevance, downloads, newest, featured, undiscovered.
- **Filters**: content types, generative AI (all, exclude, only), premium collection, orientation, added within (a
  week to two years), model release, transparent background, copy space, color, video duration.
- **Language**: keywords come in that language (20 languages), and search keywords are read in it. Titles stay as
  written by the contributor.

Example, through the API:

```json
{
  "searchQueries": ["coffee shop"],
  "maxItems": 1000,
  "maxResultsPerSearch": 1000,
  "sort": "downloads",
  "contentTypes": ["photo"],
  "aiGenerated": "exclude",
  "addedWithin": "1y"
}
```

### Output

One record per asset in the dataset. A shortened asset:

```json
{
  "type": "asset",
  "status": "ok",
  "assetId": 300428267,
  "url": "https://stock.adobe.com/300428267",
  "title": "Barista making coffee in coffee shop, hands holding cup of coffee.",
  "assetType": "photo",
  "keywords": ["people", "bar", "machine", "hot drink", "hand", "eatery", "…"],
  "keywordCount": 43,
  "downloads": 1797,
  "views": 0,
  "creatorName": "Aleksandrs Muiznieks",
  "creatorId": 206684585,
  "creatorUrl": "https://stock.adobe.com/contributor/206684585",
  "creatorCountry": "Latvia",
  "uploadedAt": "2019-11-04T20:15:00",
  "category": "Drinks",
  "categoryPath": ["Drinks"],
  "isAIGenerated": false,
  "isPremium": false,
  "hasModelRelease": false,
  "width": 4800,
  "height": 3200,
  "orientation": "horizontal",
  "fileFormat": "image/jpeg",
  "fileSizeBytes": 10522282,
  "thumbnailUrl": "https://as1.ftcdn.net/v2/jpg/03/00/42/82/500_F_300428267_QndUXocKZb92jE1RKf5fBoQUIo8bxeME.jpg",
  "previewUrl": "https://stock.adobe.com/Rest/Libraries/Watermarked/Download/300428267/2",
  "input": "coffee shop",
  "inputType": "search",
  "position": 1,
  "scrapedAt": "2026-10-12T03:59:20.090Z"
}
```

Fields that need a word of explanation:

- `status`: `ok` (delivered, charged), `unavailable` (free: an asset ID that Adobe Stock no longer shows), `error`
  (free; `error` says why, `retryable` says if a later run may work).
- `views`: Adobe Stock shows 0 for many assets (about 4 in 5 in our sample), even assets with downloads.
- `durationSeconds` and `frameRate` are set for videos only; `vectorFormat` for vectors.
- `previewUrl` is Adobe Stock's watermarked preview. Licensed files are not downloaded.

The run summary (counts per input, why the run stopped, notes) is the `OUTPUT` record of the run's key-value store.

### Pricing

Pay per event:

| Event | Price |
|---|---|
| Asset | $0.60 per 1,000 |
| Run start | $0.0006 per GB of memory (1 GB minimum; $0.0006 at the default 256 MB) |

Higher Apify plans pay less per asset. Never charged: assets that no longer exist, error records, repeats (an asset
found by two searches, or shown again by Adobe Stock, is delivered once). Set **Maximum cost per run** in the run
options and the run stops before going over it.

Speed, measured on Apify (12/10/2026): 1,000 assets in 9 s, 7,817 in 2 min 15 s.

### Limits

- **10,000 results per search.** Adobe Stock shows no more for one search. Split a bigger one with filters (content
  type, added within, orientation); the run summary says when a search reached this limit.
- **Repeats in some sorts.** Sorted by relevance, newest or featured, Adobe Stock shows some assets again on later
  pages: for `business`, 2,139 of the first 10,000 results were repeats (12/10/2026). They are skipped and not
  charged, so such a search can deliver fewer assets than you asked. Sorted by downloads, each asset comes once.
- **Sort by downloads** is Adobe Stock's own ranking: it follows downloads, but not strictly.
- **Premium only**: Adobe Stock's own filter also returns many assets outside the premium collection; they are
  skipped and not charged, so the run reads more pages for the same number of assets.
- Asset descriptions are not available, and neither are license prices (they depend on your Adobe plan).

### FAQ

**Do I need an Adobe account?** No.

**What if the run is restarted by the platform (migration or reboot)?** It resumes where it was: assets already in the
dataset are not delivered or charged again.

**Can I get the full-resolution files?** No. You get the data and the watermarked previews; files are licensed from
Adobe Stock.

**Is it legal?** It collects public data shown to any visitor of Adobe Stock. Check the rules that apply to your use of
the data, and remember that the images themselves belong to their contributors.

**Does the Actor send anything to Quarra?** Only when a run fails or runs out of time: the Actor, its build, the error type, the line of our code where it happened, and the memory and time the run was given, so we can fix it fast. Never your input, your results, your account or the run ID.

### Related tools from Quarra

- [Adobe Stock Analyzer](https://apify.com/quarra/adobe-stock-analyzer): asset URLs or IDs only, to track downloads and
  views of a list of assets.

# Actor input Schema

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

One per line: keywords (coffee shop), or an Adobe Stock search URL pasted as is (its keywords, language, sort and filters are kept). Each search returns assets in Adobe Stock order, up to 'Max results per search'.

## `assetUrls` (type: `array`):

One per line: Adobe Stock asset URLs (photos, vectors, videos, templates, 3D; any language) or asset IDs. Each gets its keywords, downloads, views and details. Assets that no longer exist get a free record.

## `contributors` (type: `array`):

One per line: Adobe Stock contributor URLs (stock.adobe.com/contributor/…) or contributor IDs. Returns their portfolio, up to 'Max results per search' each.

## `similarTo` (type: `array`):

One per line: an Adobe Stock asset URL or ID, or a direct link to a JPEG or PNG image on the web. Returns visually similar Adobe Stock assets.

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

Total number of assets delivered by the run, counted exactly. Free records (errors, assets that no longer exist) are not counted.

## `maxResultsPerSearch` (type: `integer`):

Assets per search, contributor or similar-to input, at most 10,000 (Adobe Stock shows no more per search; split a bigger search with filters).

## `sort` (type: `string`):

Order of results. A search URL keeps its own sort.

## `contentTypes` (type: `array`):

Leave empty for all types.

## `aiGenerated` (type: `string`):

Assets made with generative AI, as labeled by Adobe Stock.

## `premium` (type: `string`):

Adobe Stock's premium collection.

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

Shape of the asset.

## `addedWithin` (type: `string`):

When the asset was added to Adobe Stock.

## `withModelRelease` (type: `boolean`):

Only assets with a signed model or property release.

## `transparentBackground` (type: `boolean`):

Only assets on a transparent background.

## `copySpace` (type: `boolean`):

Only assets with empty space for text.

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

A hex color such as FF0000: assets where this color stands out.

## `videoDuration` (type: `string`):

For videos.

## `language` (type: `string`):

Language of keywords and of how search keywords are read. Titles stay as written by the contributor.

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

Connection. Keep the default (automatic). Costs are included in the price.

## Actor input object example

```json
{
  "searchQueries": [
    "coffee shop"
  ],
  "maxItems": 50,
  "maxResultsPerSearch": 50,
  "sort": "relevance",
  "aiGenerated": "all",
  "premium": "all",
  "orientation": "all",
  "addedWithin": "any",
  "withModelRelease": false,
  "transparentBackground": false,
  "copySpace": false,
  "videoDuration": "any",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Every asset with all its fields, and free records with the reason.

## `overview` (type: `string`):

One line per asset: downloads, views, keywords, contributor.

## `summary` (type: `string`):

Counts per input, total results on Adobe Stock, why the run stopped, errors.

# 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 = {
    "searchQueries": [
        "coffee shop"
    ],
    "maxItems": 50,
    "maxResultsPerSearch": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("quarra/adobe-stock-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 = {
    "searchQueries": ["coffee shop"],
    "maxItems": 50,
    "maxResultsPerSearch": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("quarra/adobe-stock-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 '{
  "searchQueries": [
    "coffee shop"
  ],
  "maxItems": 50,
  "maxResultsPerSearch": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call quarra/adobe-stock-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,quarra/adobe-stock-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/e9tWhpc9ymJLGLZAw/builds/7QFS8j2zkrg40K2fz/openapi.json