# YouTube Shopping Product Discovery (`deepmine/youtube-shopping-product-discovery`) Actor

Find products promoted in YouTube videos, Shorts, and creator channels using search queries, channel URLs, or direct video URLs.

- **URL**: https://apify.com/deepmine/youtube-shopping-product-discovery.md
- **Developed by:** [DeepMine](https://apify.com/deepmine) (community)
- **Categories:** E-commerce, Videos, Lead generation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## YouTube Shopping Product Discovery

Find products promoted in YouTube videos, YouTube Shorts, and creator content. This actor helps you discover what products creators are pushing, what shopping links appear around a keyword, and which retailers, offers, and product categories are showing up across YouTube shopping content.

If you need a **YouTube shopping scraper**, **YouTube product discovery tool**, **YouTube affiliate product scraper**, **creator storefront scraper**, or **YouTube product research actor**, this is built for that workflow.

### What this actor does

This actor discovers products promoted through:

- YouTube search results
- YouTube Shorts
- creator videos
- video description links
- shopping, merch, and product shelf links on video pages

It turns those discoveries into structured rows you can use for:

- YouTube product research
- affiliate product discovery
- creator commerce research
- influencer product tracking
- ecommerce sourcing
- retailer and offer discovery
- niche and trend research

### Best use cases

- Discover products promoted by creators in a niche
- Find YouTube shopping links for terms like `amazon finds`, `viral gadgets`, `beauty must haves`, `creator storefront finds`, `desk setup essentials`, and similar product-led queries
- Research what products influencers and affiliate creators are featuring
- Build product lists from YouTube shopping content
- Find repeated product promotions across multiple creators or videos
- Track which retailers appear most often in creator-driven product discovery content
- Source ecommerce and affiliate product ideas from YouTube
- Support TikTok Shop, Amazon, Shopify, Walmart, Etsy, and general creator-commerce research

### Who this is for

- Affiliate marketers
- ecommerce operators
- product sourcing teams
- creator partnership teams
- influencer marketing agencies
- media buyers researching creator-led product demand
- marketplace and trend researchers

### Inputs

You can run the actor with:

- **search queries** for YouTube shopping and creator-commerce discovery
- **channel URLs** for creator-specific product research
- **direct video URLs** when you want to inspect known videos or Shorts

Useful example query types:

- `amazon finds`
- `viral gadgets`
- `beauty must haves`
- `kitchen gadgets`
- `creator storefront finds`
- `home organization finds`
- `travel essentials`
- `desk setup essentials`
- `tiktok made me buy it`

### Output

Each row gives you product and video discovery context such as:

- `product_url`
- `final_product_url`
- `product_domain`
- `retailer_name`
- `product_title_guess`
- `source_type`
- `discovery_score`
- `discovery_tier`
- `video_title`
- `video_url`
- `channel_name`
- `views_text`
- `published_at`

This makes it useful for both quick manual review and downstream enrichment pipelines.

### Why people use it

- YouTube is one of the largest product discovery channels online
- creators, affiliates, and storefront-style videos constantly surface new products
- many product trends appear in creator content before they fully saturate other channels
- manual research across YouTube videos, Shorts, and creator pages is slow and inconsistent

This actor speeds that up by collecting YouTube shopping discoveries into a usable dataset.

### Typical workflows

#### YouTube affiliate product research

Run niche queries, collect discovered products, and review which offers keep appearing across creators.

#### Creator storefront and shopping link discovery

Inspect creators or videos directly to see what products they are linking and promoting.

#### Ecommerce sourcing and product validation

Use YouTube creator promotion activity as one more signal for product demand, merchandising, or trend research.

#### Retailer and offer discovery

See which domains, stores, and product sources show up across creator-led shopping content.

### Notes

- This is a **YouTube product discovery** actor, not a full external retailer catalog scraper.
- It is designed for finding product opportunities and creator-linked shopping activity, not for scraping every product detail from every retailer site.
- No proxy is required for the default workflow. Use proxy only when your specific use case needs it.

### Search terms this actor is relevant for

YouTube shopping scraper, YouTube product scraper, YouTube product discovery, YouTube affiliate scraper, YouTube creator storefront scraper, YouTube shopping links scraper, YouTube influencer product scraper, creator commerce scraper, ecommerce product research, influencer product discovery, YouTube merch shelf scraper, YouTube Shorts product discovery, creator product research, affiliate product discovery, product sourcing scraper.

# Actor input Schema

## `queries` (type: `array`):

YouTube search queries used to discover shoppable videos and product-promoting content.

## `channelUrls` (type: `array`):

Optional YouTube channel URLs to scan for product-promoting videos.

## `videoUrls` (type: `array`):

Optional direct YouTube video or Shorts URLs to inspect for product links.

## `maxResultsPerQuery` (type: `integer`):

How many videos to keep from each YouTube search query before enrichment.

## `maxVideosPerChannel` (type: `integer`):

How many videos to keep from each YouTube channel page.

## `maxProducts` (type: `integer`):

Maximum number of discovered product rows emitted to the dataset.

## `maxProductsPerVideo` (type: `integer`):

Cap how many product rows can come from a single video so one creator does not dominate the dataset.

## `maxCandidateUrlsPerVideo` (type: `integer`):

How many outbound product-like URLs to keep per video before normalization and product filtering.

## `includeShorts` (type: `boolean`):

If enabled, include YouTube Shorts results when available.

## `includeDescriptionLinks` (type: `boolean`):

Extract product candidates from video descriptions and visible outbound links.

## `includeMerchShelf` (type: `boolean`):

Extract product candidates from visible shopping, merch, or product shelf components on video pages.

## `resolveRetailerLinks` (type: `boolean`):

Normalize YouTube redirect links to their destination URLs. This does not fully browse every external store in v1.

## `minDiscoveryScore` (type: `integer`):

Only keep discovered products at or above this 0-100 score.

## `includeRaw` (type: `boolean`):

Include raw extracted link and page metadata fields in each dataset item.

## `compactNullFields` (type: `boolean`):

If true, omit null and undefined properties from emitted records.

## `requestTimeoutSec` (type: `integer`):

Navigation and extraction timeout for each YouTube page request. Lower values fail faster on slow or dead videos.

## `maxConcurrency` (type: `integer`):

Maximum concurrent browser pages used during the crawl.

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

Optional proxy settings. Leave this off for the fastest default behavior; only enable proxy when you specifically need it.

## Actor input object example

```json
{
  "queries": [
    "amazon finds",
    "creator storefront finds",
    "beauty must haves"
  ],
  "channelUrls": [],
  "videoUrls": [],
  "maxResultsPerQuery": 15,
  "maxVideosPerChannel": 20,
  "maxProducts": 200,
  "maxProductsPerVideo": 8,
  "maxCandidateUrlsPerVideo": 16,
  "includeShorts": true,
  "includeDescriptionLinks": true,
  "includeMerchShelf": true,
  "resolveRetailerLinks": true,
  "minDiscoveryScore": 0,
  "includeRaw": false,
  "compactNullFields": true,
  "requestTimeoutSec": 20,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "amazon finds",
        "creator storefront finds",
        "beauty must haves"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/youtube-shopping-product-discovery").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 = { "queries": [
        "amazon finds",
        "creator storefront finds",
        "beauty must haves",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("deepmine/youtube-shopping-product-discovery").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 '{
  "queries": [
    "amazon finds",
    "creator storefront finds",
    "beauty must haves"
  ]
}' |
apify call deepmine/youtube-shopping-product-discovery --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deepmine/youtube-shopping-product-discovery"
        }
    }
}

```

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/es3tkN8gOtcsJbFOM/builds/YStplc8f4EfzRSjVH/openapi.json