# YouTube Sponsorship Tracker: Brand Deals, Promo Codes $2/1K (`transparent_meteorite/youtube-sponsorship-tracker`) Actor

Find which YouTubers a brand sponsors, or every sponsor in a channel or niche. One row per video and sponsor: brand, domain, promo code, tracked link, ad timestamp, evidence and confidence. No login, no API key. $2 per 1,000 rows.

- **URL**: https://apify.com/transparent_meteorite/youtube-sponsorship-tracker.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Social media, Marketing, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 sponsorship founds

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

## YouTube Sponsorship Tracker: Brand Deals, Promo Codes

![YouTube Sponsorship Tracker: features, price and a real output row](https://api.apify.com/v2/key-value-stores/9BAn0msnxToXlD9TO/records/sf-youtube-sponsorship-tracker-banner-10140227.png)

[![Run it free on Apify](https://api.apify.com/v2/key-value-stores/9BAn0msnxToXlD9TO/records/sf-cta.png)](https://console.apify.com/actors/DqEQ9k0CmCUdTHNXY/input)

| Price per 1,000 videos | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| **This Actor** | **$2.00** | **$1.70** | **$1.50** | **$1.20** |
| Most-used alternative | $12.00 | $12.00 | $12.00 | $12.00 |

<sub>Pay per event, no monthly rental. Prices read from each Actor's public Apify pricing on 2026-10-15; check the Pricing tab for the current figure.</sub>

![YouTube Sponsorship Tracker sample output table from a real run](https://api.apify.com/v2/key-value-stores/9BAn0msnxToXlD9TO/records/sf-youtube-sponsorship-tracker-output-10140227.png)

Find out **which YouTubers a brand sponsors**, or **which brands sponsor a channel or a niche**. Every row is one video and one sponsor, with the brand, its domain, the promo code, the tracked link and its UTM/coupon parameters, the timestamp of the ad read, the description lines that prove it and a confidence score. No login, no YouTube API key, no daily quota. $2 per 1,000 sponsorships found.

- **In short:** YouTube Sponsorship Tracker (Apify actor `transparent_meteorite/youtube-sponsorship-tracker`) reads public YouTube pages and detects sponsor reads in video descriptions, chapters and the paid-promotion flag. It returns one flat row per (video, sponsor brand).
- **Who it is for:**
  - brand and influencer marketing teams checking where competitors spend
  - agencies building creator shortlists from proven sponsor history
  - creators and managers looking for brands that already buy YouTube ads in their niche
  - analysts tracking sponsor share of voice over time
- **Input:** brand names, channels, niche keywords, or pasted video / channel / search URLs. Empty input runs a NordVPN sample.
- **Output:** sponsorBrand, sponsorDomain, promoCode, trackedLink, linkParams, sponsorTimestamp, evidence, confidence, plus video and channel stats.
- **Detection:** deterministic rules, no AI model. Same input, same answer.
- **Pricing:** pay per sponsorship row, $0.002 on the free plan down to $0.0012 on Gold and higher.
- Access: Apify Console, REST API, JavaScript/Python clients, schedules, webhooks, Apify MCP server
- Login, cookies or YouTube API key needed: no
- Also known as: YouTube sponsor finder, YouTube brand deal tracker, influencer sponsorship database, YouTube ad read tracker, competitor sponsorship monitor

### Run in 30 seconds

1. Press **Try for free**.
2. Keep the prefilled brand (NordVPN) or type your own, then press **Start**. Ten sponsored videos take about 10 seconds.
3. Open the **Output** tab: one row per sponsorship. Download as CSV, Excel or JSON.

```json
{ "brands": ["NordVPN"], "maxVideos": 10 }
```

### What it does

The mode is picked from what you fill in:

| You fill in | What happens | Rows returned |
|---|---|---|
| **brands** only | Searches YouTube for videos that brand sponsors ("thanks to X for sponsoring", "sponsored by X", promo-code searches), then checks each video page | Only that brand's sponsorships: which creators it pays |
| **channels** | Checks the channel's newest videos | Every sponsor found in each video |
| **keywords** | Checks the top YouTube results for a niche search | Every sponsor found in each video |
| **startUrls** | Checks the pasted videos, channels or search pages | Every sponsor found |
| brands + channels/keywords/URLs | Scans as above | Only rows for the listed brands |
| nothing | Sample run for NordVPN | 20 rows |

A sponsorship is detected from signals a human reviewer would use, each with a weight:

- explicit phrases: "sponsored by", "thanks to X for sponsoring", "today's sponsor", "in partnership with", "#ad"
- offer links: tracked links with `coupon=`, `utm_*`, `ref=` and similar, creator vanity links (`brand.com/creatorname`), short links resolved once to the real domain
- promo codes ("use code CREATOR20")
- sponsor chapters ("1:14 NordVPN Ad Spot") giving the timestamp of the ad read
- YouTube's paid promotion flag and #ad disclosures

Rows below your confidence threshold, the creator's own merch and socials, negated mentions ("not sponsored by...") and Amazon gear lists are left out. Videos that only review a product with an affiliate link ("NordVPN review") are skipped unless you turn on `includeAffiliateReviews`.

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `brands` | array | NordVPN (sample) | Brand names to find, or to filter on |
| `channels` | array |  | @handle, channel URL or UC id |
| `keywords` | array |  | Niche search terms |
| `startUrls` | array |  | Video, Shorts, channel or search URLs |
| `maxVideos` | integer | 20 | Brand mode: sponsored videos to find per brand. Channel/keyword mode: videos to check per source |
| `maxItems` | integer | 0 | Hard cap on rows for the run (0 = none) |
| `publishedAfter` | string |  | `2025-01-31` or `30 days` |
| `minConfidence` | integer | 50 | 0-100. 80 keeps only explicit sponsor reads |
| `searchSort` | string | relevance | relevance, date or views |
| `includeAffiliateReviews` | boolean | false | Keep affiliate-only review videos |
| `resolveShortLinks` | boolean | true | Follow bit.ly / geni.us once to find the sponsor domain |
| `onlyNew` | boolean | false | Monitor mode: only sponsorships not delivered before |
| `maxTotalChargeUsd` | number |  | Stop before spending more than this |
| `proxyConfiguration` | object | none | Not needed for normal runs |

#### Example inputs

**Who does Surfshark sponsor this year?**

```json
{ "brands": ["Surfshark"], "maxVideos": 30, "publishedAfter": "365 days" }
```

**All sponsors of three tech channels**

```json
{ "channels": ["@mkbhd", "@LinusTechTips", "@JerryRigEverything"], "maxVideos": 15 }
```

**Sponsors in the budget travel niche**

```json
{ "keywords": ["budget travel vlog"], "maxVideos": 40 }
```

### Output sample

```json
{
  "videoId": "7NCClf7aa_c",
  "url": "https://www.youtube.com/watch?v=7NCClf7aa_c",
  "title": "Understanding Fabric Weight",
  "channelName": "Bernadette Banner",
  "channelId": "UCSHtaUm-FjUps090S7crO4Q",
  "channelUrl": "https://www.youtube.com/@bernadettebanner",
  "channelSubscribers": 2000000,
  "views": 170873,
  "publishedAt": "2026-10-11T07:00:10-07:00",
  "durationSec": 2300,
  "sponsorBrand": "NordVPN",
  "sponsorDomain": "nordvpn.com",
  "promoCode": null,
  "trackedLink": "https://nordvpn.com/bernadette",
  "linkParams": null,
  "sponsorTimestamp": "1:14",
  "sponsorTimestampSec": 74,
  "sponsorUrlAtTimestamp": "https://www.youtube.com/watch?v=7NCClf7aa_c&t=74s",
  "isPaidPromotionFlag": false,
  "hasAdDisclosure": false,
  "isAffiliateReview": false,
  "signals": ["creatorVanityLink", "thanksForSponsoring", "brandOfferMention", "sponsorChapter"],
  "evidence": "Get an exclusive NordVPN deal + 4 months extra here https://nordvpn.com/bernadette ... | Thanks to NordVPN for sponsoring this video!",
  "confidence": 0.99,
  "sponsorsInVideo": 2,
  "matchedBrand": "NordVPN",
  "fromSource": "brand",
  "fromInput": "NordVPN",
  "scrapedAt": "2026-10-13T23:59:00.000Z"
}
```

Values above come from a real run (views change over time). The **Overview** table in the Output tab shows sponsor, channel, video, views, date, domain, promo code, link, ad timestamp and confidence. The run's `OUTPUT` record has per-source counts (videos scanned, rows, skipped) and warnings.

### Pricing

Pay per event: you pay only for sponsorship rows delivered. Duplicates, rows below your confidence threshold, filtered rows and (in monitor mode) already-seen rows are never charged.

| Apify plan | Price per sponsorship | Per 1,000 |
|---|---|---|
| Free | $0.002 | $2.00 |
| Bronze | $0.0017 | $1.70 |
| Silver | $0.0015 | $1.50 |
| Gold, Platinum, Diamond | $0.0012 | $1.20 |

Set `maxItems` or `maxTotalChargeUsd` to cap a run. A 20-row sample costs about 4 cents.

### Use it from code, schedules or AI agents

- **API:** `POST https://api.apify.com/v2/acts/transparent_meteorite~youtube-sponsorship-tracker/run-sync-get-dataset-items?token=YOUR_TOKEN` with the input JSON as the body.
- **Schedules:** set `onlyNew: true`, list your competitor brands, and schedule it weekly to get only new sponsorships.
- **MCP / AI agents:** add `https://mcp.apify.com?actors=transparent_meteorite/youtube-sponsorship-tracker` to Claude, Cursor or any MCP client and ask "which YouTubers did Squarespace sponsor in the last 3 months?".

### Honest limits

- Detection reads the **description, chapters and paid-promotion flag**, not the spoken audio. A sponsor that is only spoken in the video, with no link or code in the description, is missed.
- Brand mode finds videos through YouTube search, so it returns what search surfaces for sponsor phrases: strong for big advertisers (VPNs, Squarespace, HelloFresh, Skillshare), thinner for brands that rarely appear in descriptions.
- Brand names are taken from the text or the link domain. Unknown brands behind odd tracking domains can come out as the domain name (for example `ankerfast.club`); the tracked link is always included so you can check.
- Confidence is a rule-based score, not a probability. 0.9+ means an explicit sponsor read; 0.5-0.7 means an offer link without a sponsor phrase.
- YouTube's paid-promotion flag is not always shown to logged-out visitors, so `isPaidPromotionFlag: false` does not prove a video is unsponsored.
- Only public videos. Members-only, private and age-restricted videos are skipped.

### Use cases

- **Competitive intelligence for a brand team.** Enter the names of three competitors and see which creators carry their ads, how large those channels are, which promo codes and tracked links are used, and where in the video the ad read sits. Run it again every month to see which creators are new.
- **Shortlist building for an agency.** A creator that already carries ads for brands in your category is proven to accept sponsors. Search a niche keyword and read the `sponsorBrand`, `channelName` and `channelSubscribers` columns to build a short list of channels with sponsor history.
- **Lead lists for creators and managers.** Choose a niche, collect the brands that already buy YouTube ads there, and pitch those brands. `sponsorDomain` gives the company website directly.
- **Share of voice tracking.** Count rows per `sponsorBrand` across a fixed set of channels to see which advertisers dominate a category, then repeat on a schedule.
- **Disclosure and compliance checks.** `isPaidPromotionFlag`, `hasAdDisclosure` and `signals` show whether a sponsored video also carries the platform's paid-promotion flag or an explicit ad disclosure.
- **Promo code and link research.** `promoCode`, `trackedLink` and `linkParams` list the offer codes and the UTM or coupon parameters each creator uses.

### Input guide

- **`brands`** are company names. Alone, the actor searches YouTube for videos that those brands sponsor and returns the creators behind them. Combined with `channels`, `keywords` or `startUrls`, brands act as a filter and only rows for those brands are kept.
- **`channels`** accept an `@handle`, a channel URL or a `UC...` channel id. The newest videos of each channel are checked and every sponsor found is returned.
- **`keywords`** are YouTube search terms for a niche, such as `home espresso`. The top results are checked and every sponsor found is returned.
- **`startUrls`** accepts video, Shorts, channel or search page URLs. Use it to check a hand-picked list of videos.
- **`maxVideos`** (1 to 5,000, default 20) means different things per mode. In brand mode it is the number of sponsored videos to find per brand, and the actor checks up to four times as many candidates. In channel and keyword mode it is the number of videos to check.
- **`maxItems`** caps the total number of rows for the run. 0 means no cap.
- **`publishedAfter`** skips older videos. Use a date such as `2026-01-01` or a period such as `30 days`.
- **`minConfidence`** (0 to 100, default 50) drops weaker rows, and dropped rows are not charged. At 50 the output keeps clear sponsor reads and offer links. At 80 it keeps only explicit cases such as "sponsored by", a promo code or an ad chapter.
- **`searchSort`** sets the YouTube search order used in brand and keyword mode: `relevance`, `date` or `views`. Use `date` for a recent view, `views` to surface the biggest placements.
- **`includeAffiliateReviews`** keeps review videos that only carry an affiliate link. They are flagged `isAffiliateReview`. It is off by default because most of them are not paid sponsorships.
- **`resolveShortLinks`** follows short links such as bit.ly once to find the real sponsor domain. Leave it on unless every link in your sources is already direct.
- **`onlyNew`** with **`stateStoreName`** turns on monitor mode: video and brand pairs that were already delivered are remembered by name and not returned or charged again. Use a different name for each monitor.
- **`maxConcurrency`** sets parallel page fetches, 1 to 5, default 2.
- **`autoProxyFallback`** switches to Apify residential proxy by itself when YouTube starts limiting the IP. **`proxyConfiguration`** is rarely needed.

### Output field reference

| Field | Meaning |
|---|---|
| `videoId`, `url`, `title` | The video |
| `channelName`, `channelId`, `channelUrl`, `channelSubscribers` | The channel |
| `views`, `publishedAt`, `durationSec` | Video statistics and date |
| `sponsorBrand`, `sponsorDomain` | The detected sponsor and its website domain |
| `promoCode` | Offer code read from the description, when one exists |
| `trackedLink`, `linkParams` | The sponsor link and its UTM, coupon or referral parameters |
| `sponsorTimestamp`, `sponsorTimestampSec`, `sponsorUrlAtTimestamp` | Where the ad read begins, from a sponsor chapter, and a link that opens the video at that second |
| `isPaidPromotionFlag`, `hasAdDisclosure`, `isAffiliateReview` | Disclosure and affiliate flags |
| `signals` | The detection signals that fired, for example `thanksForSponsoring` or `sponsorChapter` |
| `evidence` | The description lines that support the match |
| `confidence` | Rule-based score from 0 to 1 |
| `sponsorsInVideo` | Number of distinct sponsors found in the video |
| `matchedBrand`, `fromSource`, `fromInput` | How the row relates to your input |
| `scrapedAt` | Snapshot time |

### More worked examples

**Recent sponsors of one competitor, high confidence only**

```json
{
  "brands": ["Squarespace"],
  "maxVideos": 25,
  "publishedAfter": "90 days",
  "searchSort": "date",
  "minConfidence": 80
}
```

**Who sponsors a single creator, and where in the video**

```json
{
  "channels": ["@mkbhd"],
  "maxVideos": 20,
  "minConfidence": 70
}
```

**Weekly monitor for new deals of several brands**

```json
{
  "brands": ["NordVPN", "Surfshark", "ExpressVPN"],
  "maxVideos": 20,
  "onlyNew": true,
  "stateStoreName": "vpn-sponsor-watch",
  "publishedAfter": "30 days"
}
```

**Check a hand-picked list of videos**

```json
{
  "startUrls": [{ "url": "https://www.youtube.com/watch?v=7NCClf7aa_c" }],
  "minConfidence": 50
}
```

### Reading confidence and signals

Confidence comes from adding up weighted signals. A phrase such as "thanks to X for sponsoring" or a sponsor chapter in the timeline is strong evidence. A tracked offer link with a coupon or referral parameter is moderate evidence. A promo code adds to either. The paid-promotion flag and an ad disclosure also raise the score.

For outreach lists, `minConfidence: 80` gives fewer rows with fewer false positives. For market sizing, the default of 50 finds more placements, and a manual look at the `evidence` column settles the borderline cases. The `evidence` text is copied from the video description, so each row can be verified in one click through `url` or `sponsorUrlAtTimestamp`.

### Tips to reduce cost and runtime

- Start with `maxVideos` 10 and check the first rows before a large run. Rows below `minConfidence` are not charged, so a stricter threshold lowers the bill and the clean-up work.
- Add `publishedAfter` to avoid old videos. Sponsor deals change quickly, so a 6 to 12 month window is usually enough.
- Use `maxItems` as a hard cap on rows.
- In brand mode, search sorted by `date` shows what is new. Sorted by `views` it shows the largest placements.
- For repeat runs use `onlyNew`. Each pair of video and brand is delivered once.
- Keep `resolveShortLinks` on, so the real sponsor domain is found instead of a link shortener.

### Calling it from code

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~youtube-sponsorship-tracker/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"brands":["NordVPN"],"maxVideos":10}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("APIFY_TOKEN")
run = client.actor("transparent_meteorite/youtube-sponsorship-tracker").call(
    run_input={"channels": ["@mkbhd"], "maxVideos": 10}
)
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["channelName"], row["sponsorBrand"], row["promoCode"], row["confidence"])
```

### More questions

**Can it find the sponsor of a video that only mentions the brand in speech?** No. Detection reads the description, chapters and paid-promotion flag, not the audio.

**Why does a brand search return fewer videos than I asked for?** Brand mode relies on what YouTube search surfaces for sponsor phrases. Brands that rarely appear in descriptions give fewer rows.

**Does it work on Shorts?** Shorts URLs can be pasted in `startUrls` and are checked like other videos.

**Can I filter by channel size?** The output has `channelSubscribers`, so filter in your table or spreadsheet.

**What does `sponsorsInVideo` mean?** It is the number of distinct sponsors found in that one video. Each sponsor has its own row.

**Are results the same on every run?** Detection uses fixed rules, so the same videos give the same answer. New videos, view counts and search results change over time.

**How do I export for a spreadsheet?** Use the Output tab to download CSV or Excel. The Overview table shows the main columns.

### FAQ

**Do I need a YouTube API key?** No. The actor reads the same public pages a logged-out browser sees.

**Does it use AI?** No. Detection is deterministic rules, so results are repeatable and cheap.

**Can I get only new sponsorships every week?** Yes. Turn on `onlyNew`; delivered video + brand pairs are remembered in a named key-value store and not charged again.

**Does it find the creator's email?** No. It returns the channel URL and handle; contact details are out of scope.

**Do I need a proxy?** No for normal runs. If YouTube rate-limits the IP, the run switches to Apify residential proxy by itself (turn `autoProxyFallback` off to prevent this).

### Legal note

The actor reads only public YouTube pages that anyone can open without logging in, and returns business information about public sponsorship placements: brands, public videos and public channel pages. It does not collect private personal data. You are responsible for using the results in line with YouTube's terms and the laws that apply to you.

New to Apify? [Create a free account](https://console.apify.com/sign-up?fpr=rnmakg) and run this Actor in under a minute. Some links are affiliate links.

# Actor input Schema

## `brands` (type: `array`):

Brand names to track, e.g. NordVPN, Squarespace, HelloFresh. Brands alone: the actor searches YouTube for videos those brands sponsor. Together with channels, keywords or URLs: only rows for these brands are kept. Leave everything empty for a NordVPN sample run.

## `channels` (type: `array`):

YouTube channels whose recent videos you want to check for sponsors: @handle, channel URL or UC... id. Every sponsor found is returned.

## `keywords` (type: `array`):

YouTube search terms for a niche, e.g. "budget travel vlog" or "home espresso". The top videos are checked and every sponsor is returned.

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

Paste any YouTube URLs: videos, Shorts, channels or search pages. Each is checked for sponsors.

## `maxVideos` (type: `integer`):

Brand mode: how many sponsored videos to find per brand (the actor checks up to 4x more candidates). Channel and keyword mode: how many recent or top videos to check.

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

Hard cap on rows (and charges) for the whole run.

## `maxTotalChargeUsd` (type: `number`):

Stop the run once this much would be charged. Leave 0 to use only the run's own spending limit.

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

Skip older videos. A date (2025-01-31) or a relative period (30 days, 6 months).

## `minConfidence` (type: `integer`):

Rows below this confidence are dropped and not charged. 50 keeps clear sponsor reads and offer links; 80 keeps only explicit "sponsored by" / promo code / ad-chapter cases.

## `searchSort` (type: `string`):

Order of YouTube search results used in brand and keyword mode.

## `includeAffiliateReviews` (type: `boolean`):

Off by default: videos titled like "NordVPN review" or "best VPN" with only an affiliate link are usually not paid sponsorships. Turn on to keep them (they are flagged isAffiliateReview).

## `resolveShortLinks` (type: `boolean`):

Follow bit.ly, geni.us and similar short links once (HEAD request) to find the real sponsor domain. Recommended.

## `onlyNew` (type: `boolean`):

Remember delivered video + brand pairs between runs and return (and charge) only new ones. Schedule it daily or weekly.

## `stateStoreName` (type: `string`):

Named key-value store that holds what was already delivered. Use a different name per monitor.

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

Pages fetched at once. 2 is polite and fast enough; max 5.

## `autoProxyFallback` (type: `boolean`):

On by default: if YouTube starts rate-limiting the IP, the run switches itself to Apify residential proxy instead of returning nothing.

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

Not needed for normal runs: public YouTube pages load fine without a proxy.

## Actor input object example

```json
{
  "brands": [
    "NordVPN"
  ],
  "maxVideos": 20,
  "maxItems": 0,
  "maxTotalChargeUsd": 0,
  "minConfidence": 50,
  "searchSort": "relevance",
  "includeAffiliateReviews": false,
  "resolveShortLinks": true,
  "onlyNew": false,
  "stateStoreName": "youtube-sponsorship-tracker-seen",
  "maxConcurrency": 2,
  "autoProxyFallback": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "brands": [
        "NordVPN"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/youtube-sponsorship-tracker").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 = { "brands": ["NordVPN"] }

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/youtube-sponsorship-tracker").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 '{
  "brands": [
    "NordVPN"
  ]
}' |
apify call transparent_meteorite/youtube-sponsorship-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/youtube-sponsorship-tracker"
        }
    }
}
```

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/DqEQ9k0CmCUdTHNXY/builds/esQIRYcHnGA3afQ0O/openapi.json