# Sponsor & Advertiser Finder — YouTube, Podcasts & Newsletters (`insight.solutions/sponsorship-intelligence-api`) Actor

Which brands sponsor which channels, shows and newsletters: one row per brand per video, episode or post, with domain, promo code, offer, sponsor link, the sentence it came from and a confidence grade. Read from public descriptions and show notes. No host or author data. No login, no key.

- **URL**: https://apify.com/insight.solutions/sponsorship-intelligence-api.md
- **Developed by:** [Insight Solutions](https://apify.com/insight.solutions) (community)
- **Categories:** Lead generation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 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

## Sponsor & Advertiser Finder — YouTube, Podcasts & Newsletters

**Find out which brands sponsor which YouTube channels, podcasts and newsletters.** Give this Actor a list of channels, shows or Substack publications and get back one row per brand per video, episode or post: the **brand**, its **domain**, the **promo code** and **offer**, the **sponsor link**, the **sentence it was read from**, and a **confidence** grade. Plus one row per scanned item — sponsored or not — and a summary per source with every brand's count and first and last appearance. JSON, CSV or Excel.

The sponsorship is written in public text: a YouTube description ("This video is sponsored by …", "use code X for 20% off"), a podcast's show notes ("Thank you to our sponsors: AG1, LMNT, Eight Sleep"), a newsletter post ("Today's issue is brought to you by …"). This Actor reads that text — the full description of each video, the full notes of each episode, the body of each post — and turns it into rows. HTTP only: no browser, no login, no API key.

**Company-level data only.** Brands, channels, shows and publications are organisations; no row names a host, an author, an owner or a guest. **$3.00 per 1,000 sponsorships** plus **$0.50 per 1,000 items scanned** on the FREE tier.

### Try it in 30 seconds

This is the Store prefill; paste it and run:

```json
{ "mode": "podcast", "podcasts": ["Huberman Lab", "Lex Fridman Podcast", "The Tim Ferriss Show"], "maxItemsPerSource": 10 }
```

Three shows that list their sponsors in every episode's notes, ten newest episodes each: about 30 item rows and — on the pinned copies of the first two feeds in our test suite — **100 sponsorships from those two shows alone** (Huberman Lab 39, Lex Fridman Podcast 61), every one `high` confidence. It is six requests: one Apple search per show (a few KB, through the datacenter proxy) and one feed download per show (direct, however many episodes you ask for).

A YouTube channel and a newsletter in one run:

```json
{
  "mode": "mixed",
  "youtubeChannels": ["@LinusTechTips"],
  "newsletters": ["lenny"],
  "maxItemsPerSource": 20,
  "since": "2026-09-01"
}
```

Tracking a few brands across many shows:

```json
{ "mode": "podcast", "podcasts": ["Huberman Lab", "Modern Wisdom", "The Diary Of A CEO"], "brands": ["AG1", "LMNT", "eightsleep.com"], "maxItemsPerSource": 50 }
```

**From code** — `client.actor("insight.solutions/sponsorship-intelligence-api").call(run_input={"podcasts": ["Huberman Lab"]})` with `apify-client`, or `POST https://api.apify.com/v2/acts/insight.solutions~sponsorship-intelligence-api/run-sync-get-dataset-items`.

### What comes back

A **sponsorship** row (from the pinned Huberman Lab feed; null columns cut):

```json
{
  "rowType": "sponsorship",
  "source": "podcast",
  "sourceTitle": "Huberman Lab",
  "itemTitle": "How Mitochondria Control Your Metabolism | Dr. Jared Rutter",
  "itemUrl": "https://www.hubermanlab.com/episode/how-mitochondria-control-your-metabolism-jared-rutter",
  "publishedAt": "2026-09-07T08:00:00.000Z",
  "brand": "Function Health",
  "brandDomain": "functionhealth.com",
  "url": "https://functionhealth.com/huberman",
  "finalDomain": "functionhealth.com",
  "evidence": "Thank you to our sponsors: Function: https://functionhealth.com/huberman",
  "confidence": "high",
  "signal": "sponsor-block",
  "showTitle": "Huberman Lab",
  "feedUrl": "https://feeds.megaphone.fm/hubermanlab"
}
```

The name was written as "Function" and the link goes to `functionhealth.com`; the alias table knows them as one company, and the episode's timestamp line "Sponsor: Function" is folded into the same row rather than counted twice. When a show's link and the brand's own domain differ, both are kept — from the pinned Lex Fridman feed:

```json
{ "brand": "NetSuite", "brandDomain": "netsuite.com", "url": "http://netsuite.ai/lex", "finalDomain": "netsuite.ai", "evidence": "SPONSORS: NetSuite: Business management software. Go to http://netsuite.ai/lex", "confidence": "high" }
```

A YouTube read with a code and an offer comes back the same way: `"promoCode": "LINUS"`, `"offerText": "Get 70% off a 2-year plan"`.

An **item** row — one per scanned video, episode or post, sponsored or not:

```json
{
  "rowType": "item",
  "sourceTitle": "Lex Fridman Podcast",
  "itemTitle": "#501 – DHH: Future of Programming, AI, Agentic Engineering, Vibe Coding & Linux",
  "publishedAt": "2026-08-26T21:47:04.000Z",
  "sponsorCount": 8,
  "brands": ["Wispr Flow", "Blitzy", "NetSuite", "Shopify", "LMNT", "Plaud", "Higgsfield AI", "Perplexity"],
  "creatorLinks": ["https://lexfridman.com/sponsors/ep501-sc", "https://lexfridman.com/survey", "…"],
  "descriptionChars": 2405
}
```

And one free **source** row per channel, show or publication:

```json
{
  "rowType": "source",
  "sourceTitle": "Huberman Lab",
  "itemsScanned": 10,
  "itemsWithSponsors": 10,
  "sponsorshipCount": 39,
  "distinctBrands": 11,
  "brandCounts": [
    { "brand": "AG1", "brandDomain": "drinkag1.com", "items": 10, "firstSeen": "2026-08-10T08:00:00.000Z", "lastSeen": "2026-09-10T08:00:00.000Z" },
    { "brand": "LMNT", "brandDomain": "drinklmnt.com", "items": 7, "firstSeen": "2026-08-10T08:00:00.000Z", "lastSeen": "2026-09-10T08:00:00.000Z" },
    { "brand": "Eight Sleep", "brandDomain": "eightsleep.com", "items": 6, "firstSeen": "2026-08-13T08:00:00.000Z", "lastSeen": "2026-09-10T08:00:00.000Z" }
  ],
  "requests": 2
}
```

Anything that could not be read — a show Apple does not list, a private video, a feed that moved, a refused request — comes back as a free **diagnostic** row (`errorType`, `error`) instead of a charge.

### Use cases

- **Agencies selling sponsorships** — which brands already buy integrations on shows like your clients', what codes and landing pages they use, how often they come back: the warm lead list for an ad sales team.
- **Brand competitive intelligence** — where your competitors sponsor, since when (`firstSeen`), how consistently (`items` out of `itemsScanned`), and with which offers.
- **Creator rate and fit benchmarking** — how many sponsors a channel or show carries per episode, which categories buy it, and whether the roster is stable or churning.
- **Lead lists of brands that already buy sponsorships** — a company that runs creator reads has a budget and a team for it; `brand` + `brandDomain` across a few hundred shows is a list of exactly those companies.
- **Sponsor-tracking dashboards** — run it on a schedule with `since`, append the rows, and chart brands by source and by month.

To see the ads the same brands buy on Google — every image, video and text ad a verified advertiser runs, with first and last shown dates — use our [Google Ads Transparency API](https://apify.com/insight.solutions/google-ads-transparency-api).

### How it compares

- **Read from the sponsorship itself, not estimated.** Panel- and sample-based ad-intelligence tools model who probably advertises where. This Actor returns the sponsorship as the creator published it, with the sentence it came from in `evidence`, so every row can be checked by opening `itemUrl`.
- **Three source types, one schema.** YouTube descriptions, podcast show notes and Substack posts come back in the same columns, so a brand that sponsors a channel *and* a show *and* a newsletter is one `brandDomain` across all three.
- **Every scanned item counts, not just the hits.** `item` rows and the per-source `brandCounts` make "AG1 sponsored 10 of the last 10 episodes" a number rather than a guess.
- **A grade on every row.** `high`, `medium` and `low` say what the row rests on — a sponsor block with a link, a phrase naming the brand, or only an affiliate-looking link — so a lead list can be filtered to what you trust.
- **Organisations only.** No host, author, owner, byline or guest field is read into a row, and social-profile links — which can identify a person — are recognised and dropped.

### How detection works, and the confidence scale

Each item's text is read in full — the player response's complete YouTube description (the upload list only carries a snippet), every version of an episode's notes in the feed (`content:encoded`, `description` and `itunes:summary`, merged so no line is lost or doubled), a post's whole body — with HTML turned into lines and every link kept where it sat, including links hidden behind anchor text. Then four readers run:

1. **Sponsor blocks.** A heading — "Thank you to our sponsors", "SPONSORS:", "This episode is brought to you by:", "…checking out our sponsors:" — followed by one sponsor per line: `AG1: https://drinkag1.com/huberman`, or a name line with its link on the next line (`Wispr Flow: AI-powered voice dictation app.` / `Go to https://wisprflow.ai/lex`). The block ends at a timestamp, another heading or a line that is not an entry. An inline list on the heading's own line ("Sponsors: AG1, LMNT and Eight Sleep") is one entry per name.
2. **Phrases** in running text: `sponsored by`, `brought to you by`, `thanks to … for sponsoring`, `today's sponsor`, `this episode is supported by`, `paid partnership`, `Sponsor: …` (a timestamp line), and — only with a link, a code or a known brand beside them — `presented by` and `in partnership with`. German, Spanish and French: `gesponsert von`, `patrocinado por`, `sponsorisé par`. A negation ("not sponsored by") and an audience ("brought to you by viewers like you") are never a sponsor.
3. **Offers.** `use code X`, `promo code X`, a capitalised `code X`; `get 20% off`, `free trial at …`; `go to <domain>/<the creator's slug>` (`shopify.com/lex`); `#ad` and `#sponsored`. A code or offer attaches to the sponsor in its sentence, its line or the line above, or makes a sponsorship from its own link.
4. **Affiliate links** with nothing else around them: a path or query carrying the creator's slug (`/huberman`, `?utm_source=lexfridman`), `ref=` and similar parameters, `/partner`, `/promo`, a `partner.` subdomain, or a known shortener or affiliate redirector (`bit.ly`, `geni.us`, `lmg.gg`, `shopmy`, …). Not inside a links section ("EPISODE LINKS:", "Follow us"), and never on a possessive label ("Don's LinkedIn").

**Never a sponsorship:** the creator's own site and its own membership page (returned as `creatorLinks`, free), social profiles, the platforms the show is published on (YouTube, Apple, Spotify, Substack, the feed host), and any bare domain with no phrase or affiliate marker around it — a guest's website or a book is not an advertiser.

**The brand** is the name the creator wrote, normalised through an alias table of about seventy companies that buy most creator sponsorships (so `Better Help` is `BetterHelp`, `Athletic Greens` is `AG1`, and `drinklmnt.com` is LMNT), or — with no name written — the link's domain title-cased (`wisprflow.ai` → "Wispr Flow" from the table, `davidprotein.com` → "Davidprotein" without it). A brand that is not in the table is still found; the table is a normaliser, not a whitelist. One row per brand per item, de-duplicated on `brandDomain` (else the name), keeping the strongest evidence and every code, offer and link either version had.

**The confidence scale:**

| `confidence` | What it rests on | Example |
|---|---|---|
| `high` | A sponsorship phrase or sponsor block **and** a link to the brand or a promo code | `AG1: https://drinkag1.com/huberman` under "Thank you to our sponsors" |
| `medium` | A phrase or sponsor-block entry naming the brand, with no link or code | "This episode is sponsored by Claude." |
| `low` | An affiliate-pattern link and nothing else — a lead, not a fact | `Earbuds I use: https://buyraycon.com/linus` |

A text-level `#ad` lifts a lone affiliate link from `low` to `medium`. `signal` names the rule that fired (`sponsor-block`, `sponsored-by`, `promo-code`, `affiliate-creator-slug`, …). On the two pinned real feeds in the test suite every one of the 156 sponsorships is `high` except one `medium` (an old Lex Fridman episode whose only link for that sponsor is the show's own redirect).

### Input reference

| Field | Type | Default | What it does |
|---|---|---|---|
| `mode` | select | `podcast` | `youtube`, `podcast`, `newsletter` or `mixed` (all three lists). A list the mode does not read is ignored. |
| `youtubeChannels` | string\[] | `[]` | Handles (`@mkbhd`), channel URLs or `UC…` IDs. |
| `podcasts` | string\[] | prefill: 3 shows | Show names (resolved through Apple's search, first hit), Apple Podcasts links or IDs, or RSS feed URLs. |
| `newsletters` | string\[] | `[]` | Substack subdomains (`lenny`), publication URLs (custom domains too) or post links (their publication is read). |
| `maxItemsPerSource` | integer | 30 (prefill 10) | 1–500 newest videos, episodes or posts per source. |
| `since` | string | — | `2026-09-01` (midnight UTC) or a full timestamp. Older items are skipped and never billed. Not a date → the run fails before any request. |
| `brands` | string\[] | `[]` | Report only sponsorships matching one of these names (`AG1`, `Athletic Greens`) or domains (`drinkag1.com`). Item rows still come back, with only the matching brands. |
| `includeItemsWithoutSponsors` | boolean | `true` | Return an `item` row for every scanned item; off, only items carrying a (matching) sponsorship are returned — and billed. |
| `resolveLinks` | boolean | `false` | Follow each sponsor link and each shortener once, redirects only, body never read, 5 s each, cached: fills `finalDomain` with where it lands, and names the brand behind a shortener. Time, not money. |
| `maxConcurrency` | integer | 3 | Sources scanned at once (1–10). |
| `maxRunSecs` | integer | 240 | 30–3,600. Rows already returned are kept — and billed — when it runs out. |
| `proxyConfiguration` | object | `{ "useApifyProxy": true }` | Apify datacenter by default. See *Limits* for which requests use it. |

Duplicates are dropped on what each entry names (`@NASA` twice, a show by name and by the same name in another case, two links to one publication), so nothing is read or billed twice. A run with nothing usable to read — an empty list for the mode, entries that are none of the three, a `since` or `mode` that is not valid — finishes **FAILED** before a single request, with a free row saying which entry was the problem.

### Output reference

Every row has the same columns, `null` where a column does not apply, so the dataset exports as one table. `rowType` is `sponsorship`, `item`, `source` or `diagnostic`.

**On every row:** `ok`, `rowType`, `input` (your entry, as typed), `source` (`youtube` · `podcast` · `newsletter`), `sourceTitle` (channel, show or publication title), `sourceUrl`, `errorType`, `error`, `scrapedAt`.

**Sponsorship and item rows:** `itemId` (video ID, episode GUID or post ID — the join key), `itemTitle`, `itemUrl`, `publishedAt`, and per source:

| Source | Columns |
|---|---|
| YouTube | `videoId`, `viewCount`, `channelTitle`, `channelId`, `channelUrl`, `proxyPath` (`datacenter`, `residential` or `direct` — which exit answered) |
| Podcast | `episodeGuid`, `episodeUrl`, `audioUrl`, `durationSecs`, `showTitle`, `feedUrl` |
| Newsletter | `canonicalUrl`, `postDate`, `publicationName`, `publicationUrl` |

**Sponsorship rows** (paid): `brand`, `brandDomain`, `promoCode`, `offerText` (≤ 200 characters), `url` (the sponsor link as published), `finalDomain`, `evidence` (the sentence or block line, ≤ 300 characters), `confidence`, `signal`.

**Item rows** (paid): `sponsorCount`, `brands[]`, `creatorLinks[]` (the source's own site and membership page), `descriptionChars`.

**Source rows** (free): `itemsScanned`, `itemsWithSponsors`, `sponsorshipCount`, `distinctBrands`, `brandCounts[]` (`brand`, `brandDomain`, `items`, `firstSeen`, `lastSeen`, most frequent first), `itemsSkipped` (older than `since`), `requests`, `diagnostics`.

**Diagnostic rows** (free):

| `errorType` | Meaning |
|---|---|
| `invalid-input` | An entry that is not a handle, show, feed or publication; a `mode` or `since` that is not valid. |
| `not-found` | No such channel, show, feed, publication or post; a private or members-only video; a show Apple lists with no public feed. |
| `blocked` | A 403, 429 or bot-check, twice, from two exits (and, for a YouTube video, once more through a residential exit). |
| `consent-wall` | YouTube served the EU consent page instead of the video, on every path. |
| `timeout` | A request that did not answer in time, or the run's budget running out. Rows already returned are kept. |
| `parse-failed` | An answer without the data this Actor reads — a web page where a feed should be, a player response with no video details. |
| `unavailable` | Any other upstream refusal, such as a video YouTube will not play on any client. |
| `internal` | This Actor's own error. The run is then FAILED. |

### Pricing

| Event | What it is | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|---|
| `actor-start` | Once per run, only after the run has returned a paid row | $0.001 | $0.001 | $0.001 | $0.001 |
| **`sponsorship`** | One brand on one video, episode or post | **$0.003** | **$0.003** | **$0.0024** | **$0.0018** |
| `item` | One scanned video, episode or post, sponsored or not | $0.0005 | $0.0005 | $0.0005 | $0.0005 |

**$3.00 per 1,000 sponsorships**, plus $0.50 per 1,000 items scanned.

| Run | Cost |
|---|---|
| The prefill as the offline test suite runs it — 30 items, 118 sponsorships | **$0.370** |
| Its two real shows alone, on their pinned feeds — 20 items, 100 sponsorships | **$0.311** |
| A YouTube channel with no sponsor reads, 30 videos | **$0.016** |
| 10 shows × 20 episodes at 5 sponsors an episode | **≈ $3.10** |
| The same, tracking one brand with `brands` | **≤ $0.701** |

The prefill's third show has no pinned capture, so the suite reads a hand-written feed for it; a live run costs the $0.311 of the first two shows plus $0.005 for the third show's ten items plus $0.003 per sponsor its notes name.

Charging is charge-after-push: rows are in your dataset before the event is recorded. An item is delivered **whole or not at all** — its item row and all of its sponsorship rows are checked against `ACTOR_MAX_TOTAL_CHARGE_USD` together — and the run stops fetching when the next item would not fit, finishing SUCCEEDED and saying so. Never charged: source rows, diagnostic rows, items older than `since`, items that could not be read, sponsorships your `brands` filter excluded, and a run that returns nothing (start fee included). A run that scanned items and found no sponsorship is SUCCEEDED — "Scanned N items, no sponsorships detected" — and its item rows bill.

### Limits

- **Only written sponsorships are visible.** A sponsor read that is spoken in the video or the audio but not written in the description, and podcast ads inserted dynamically by the host platform, never appear in the text this Actor reads. A show with no sponsors in its notes may still run ads.
- **YouTube: datacenter first, residential only where earned.** The upload list and every `player` request start on Apify's datacenter proxy; a request refused twice (two exits) is repeated once through a residential exit the Actor creates itself, at most once per video, and a channel list refused twice is walked once through it. `proxyPath` on each item says which answered. A video refused everywhere is a free `blocked` row.
- **Podcasts and Substack go direct first.** Feeds and Substack's endpoints are fetched without a proxy and moved to the datacenter proxy only after a host refuses; Apple's search and lookup go through the proxy.
- **Paywalled posts** are read as Substack serves them to a visitor: the free preview. A sponsor named below the paywall is not seen.
- **A show name is Apple's first search hit.** Check `sourceTitle` and `feedUrl`, or pass the Apple link or the feed URL to be exact.
- **YouTube dates**: `publishedAt` comes from the player response when the client that answered sends a date, otherwise from the upload list's "3 weeks ago" (approximate, as the text is). With `since`, the list stops at the first upload whose approximate date is more than 45 days before the cutoff, and each fetched video is then judged on its date.
- **Languages**: English phrases throughout, plus `gesponsert von`, `patrocinado por` and `sponsorisé par`. A sponsor block in another language is found through its links and codes, not its heading.
- **The alias table normalises about seventy brands.** Others keep the name as written; two spellings of an unlisted brand that share no domain stay two brands.
- **Limits per run:** 500 items per source; `maxRunSecs` up to 3,600 s. Player requests within one channel are paced 100–300 ms apart and list pages 250–600 ms apart.
- The upstream formats may change: this Actor reads YouTube's InnerTube JSON, RSS feeds and Substack's JSON as they are served today, and returns a free `parse-failed` row rather than a wrong one when an answer no longer has the data it expects.
- Not affiliated with YouTube, Apple, Substack, or any brand, channel, show or publication named in the output. Names are used descriptively, to say what was read and what was found.

### Use it from an AI agent, or from code

One JSON object in, one flat array out — the shape agent runtimes want. The Actor runs with **limited permissions** and **pay-per-event** pricing and never enters Standby, so it works over the Apify MCP server (`mcp.apify.com`) and with agentic (x402) payments. The **Integrations** tab pushes results to Slack, a webhook, Zapier, Make, Google Sheets, Snowflake or BigQuery, and Apify Schedules run it unattended — with `since`, each run reads only what is new.

```bash
curl -X POST "https://api.apify.com/v2/acts/insight.solutions~sponsorship-intelligence-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"podcast","podcasts":["Huberman Lab","Lex Fridman Podcast"],"maxItemsPerSource":20}'
```

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("insight.solutions/sponsorship-intelligence-api").call(run_input={
    "mode": "mixed",
    "podcasts": ["Huberman Lab"],
    "youtubeChannels": ["@LinusTechTips"],
    "maxItemsPerSource": 20,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["rowType"] == "sponsorship" and row["confidence"] != "low":
        print(row["sourceTitle"], row["publishedAt"], row["brand"], row["brandDomain"], row["promoCode"], sep=" | ")
    elif row["rowType"] == "source":
        print(row["sourceTitle"], [(b["brand"], b["items"]) for b in row["brandCounts"][:5]])
```

**Building an app with Lovable?** Apify's Lovable connector runs any Actor from inside a Lovable project with your Apify token. Connect Apify in Lovable once, then ask it: *"Use Apify to run insight.solutions/sponsorship-intelligence-api for my list of podcasts and build a sponsor-tracking dashboard around the results."* At the default settings a run of a few shows finishes well inside Lovable's 300-second synchronous limit, and every result is one JSON object per row, so the generated app needs no extra parsing. Usage bills to the Apify account whose token is connected.

### FAQ

**Why does a show I know is sponsored come back with no sponsorships?**
Its sponsors are not written in its show notes — the ads are read aloud, or inserted into the audio by the hosting platform. This Actor reads text; the `item` rows (with `descriptionChars`) show exactly what was scanned. Many shows do write every sponsor down, and those are the ones this finds in full.

**What is the difference between `brandDomain` and `finalDomain`?**
`brandDomain` is the company's own domain — from the alias table for a known brand, else the sponsor link's. `finalDomain` is where the published link goes: the same domain, a different one (`netsuite.ai` for NetSuite), or, with `resolveLinks`, wherever its redirects end. Group by `brandDomain`.

**Should I trust `low` rows?**
Treat them as leads. A `low` row is a link that looks like a sponsor's tracking link — the creator's slug in the path, a `ref=`, a shortener — with no sponsorship wording around it. It is often an affiliate link the creator earns commission on, which is a commercial relationship, but not always a paid sponsorship. Filter on `confidence` to taste.

**How is "Sponsor: Eight Sleep" in a timestamp list counted?**
As the same sponsorship as the "Eight Sleep: https://eightsleep.com/huberman" line in the sponsor block above it: one row, carrying the block's link and its `high` grade.

**Can it tell me how much a brand paid?**
No. Sponsorship prices are not published in descriptions. What this gives you is who, where, how often and since when — the inputs a rate estimate starts from.

**Does it read the creator's or guests' social links?**
It recognises them so they are never counted as sponsors, and leaves them out of every row: a profile link can identify a person. The source's own website and membership page are returned in `creatorLinks`.

**Can I scan only new episodes each week?**
Yes: schedule it with `since` set to last week's date. Older items are skipped before they are scanned and are never billed.

### Legal and data-protection notes

- **Public text only.** Everything this Actor reads is served to any anonymous visitor: YouTube's public upload lists and player responses, Apple's public podcast search, the RSS feeds publishers distribute for anyone to read, and Substack's public archive and post endpoints. It never logs in, never supplies cookies or session tokens, and never accepts credentials.
- **Organisations, not people.** Brands, channels, shows and publications are organisations, and they are what the rows describe. Creator names appear only where they are part of a channel's, show's or publication's own title. No host, author, owner, byline or guest field is read into a row: the feed's `itunes:author` and `itunes:owner`, Apple's artist name and Substack's bylines are dropped before a row is built, and social-profile links are never copied. Video, episode and post titles and the quoted `evidence` sentence are returned as published.
- **No profiling of individuals.** There is no person search and no input that names a person; the Actor cannot be pointed at an individual.
- **We are not a data broker.** This Actor holds no database and sells no list. It reads public text on demand and writes the result to *your* dataset on *your* account.
- **Not affiliated with, endorsed by or sponsored by** YouTube, Google, Apple, Substack, any brand detected, or any channel, show or publication read. Names and trademarks are used descriptively.
- **You are responsible for how you use the output**, including any outreach to the brands or creators it names, under the GDPR, the CCPA, ePrivacy, CAN-SPAM and applicable marketing law. Nothing here is legal advice.

### Our other Actors

Every Insight Solutions Actor is pay-per-result with no browser, no login and no API key, and every one of them returns free diagnostic rows instead of billing for failures. Prices are per 1,000 results.

**Video, audio & social**

- [YouTube Transcript API](https://apify.com/insight.solutions/youtube-transcript-api) — captions as timed segments, text, SRT or VTT, with language fallback and translation.
- [YouTube Comments API](https://apify.com/insight.solutions/youtube-comments-api) — comments and replies with likes, pinned and hearted flags, newest or top sort.
- [YouTube Channel API](https://apify.com/insight.solutions/youtube-channel-api) — a channel's videos, Shorts and live streams, plus YouTube search.
- [Podcast Search, Episodes & Charts API](https://apify.com/insight.solutions/podcast-api) — Apple Podcasts search, charts and full episode feeds.
- [Bluesky Scraper](https://apify.com/insight.solutions/bluesky-scraper) — profiles, posts, followers and follows from the public AT Protocol API.
- [Telegram Channel Scraper](https://apify.com/insight.solutions/telegram-channel-scraper) — posts, views and channel stats from public Telegram channels.
- [Substack Scraper](https://apify.com/insight.solutions/substack-scraper) — posts with full free text, comments and publication profiles.
- [Google Ads Transparency API — Advertisers, Ads & Creatives](https://apify.com/insight.solutions/google-ads-transparency-api) — every ad a verified advertiser runs on Google, from the Ads Transparency Center, by brand name, AR id or domain: format, first and last shown, days shown and preview links, individuals excluded.
- [Hacker News API](https://apify.com/insight.solutions/hacker-news-api) — stories, comments, users, front page and a structured "Who is hiring?" parser from the official HN APIs.
- [GitHub Repos, Trending & Releases API](https://apify.com/insight.solutions/github-repos-api) — repository facts, trending lists, releases and search, no token needed for small runs.
- [Discourse Forum API](https://apify.com/insight.solutions/discourse-forum-api) — topics, posts and categories from any Discourse community via its own JSON endpoints, usernames only.

**News, documents & the web**

- [Google News Search, Topics & Real Article URLs](https://apify.com/insight.solutions/google-news-api) — news search and topic feeds with the publisher's real URL decoded.
- [Website to Markdown — Content Extractor for LLMs & RAG](https://apify.com/insight.solutions/website-content-extractor) — any site as clean Markdown, text and heading-aware chunks.
- [WordPress Posts & Pages API](https://apify.com/insight.solutions/wordpress-posts-api) — posts and pages from any WordPress site as clean text or Markdown, with categories, tags and images.
- [Website Metadata API](https://apify.com/insight.solutions/website-metadata-api) — any URL's meta tags, Open Graph, Twitter cards, hreflang, feeds, JSON-LD and microdata, with normalised Product, Article, Event and FAQ entities.
- [Subdomain Finder API](https://apify.com/insight.solutions/subdomain-finder-api) — every subdomain of a domain from certificate-transparency logs, resolved over DNS, with an optional live HTTP check.
- [Internet Archive API](https://apify.com/insight.solutions/internet-archive-api) — archive.org search, item metadata, files and reviews.
- [Wayback Machine Toolkit](https://apify.com/insight.solutions/wayback-toolkit) — archived URL inventories, snapshots and text diffs between dates.
- [Website Technology Detector](https://apify.com/insight.solutions/website-tech-detector) — the tech stack behind any site, with the evidence for each detection.
- [Domain Intelligence API](https://apify.com/insight.solutions/domain-intelligence-api) — DNS, RDAP registration, TLS certificate and HTTP facts in one row per domain.
- [SEO Page Audit](https://apify.com/insight.solutions/seo-page-audit) — sitemap crawl with on-page checks, structured data and broken-link reports.
- [Keyword Suggestions API](https://apify.com/insight.solutions/keyword-suggestions-api) — Google, YouTube, Bing, Amazon and eBay autocomplete with alphabet and question expansions.
- [Website Contact Extractor](https://apify.com/insight.solutions/website-contact-extractor) — emails, phone numbers and social profiles from any list of websites.
- [Company Contact Finder](https://apify.com/insight.solutions/company-contact-finder) — company names in, each one's verified website with its business emails, phone numbers and social profiles out.
- [Web Search Results API](https://apify.com/insight.solutions/web-search-api) — Bing and DuckDuckGo organic results with snippets, no key, no browser.
- [Company Enrichment API](https://apify.com/insight.solutions/company-enrichment-api) — a domain in, a company profile out: firmographics, contacts, tech stack, DNS and hiring signal.
- [Company Dossier API](https://apify.com/insight.solutions/company-dossier-api) — one company in, twelve sections out: profile, tech, contacts, DNS, open roles, news, SEC filings, federal awards, recalls, YC batch and apps.
- [Press Releases API](https://apify.com/insight.solutions/press-releases-api) — GlobeNewswire and PR Newswire releases plus any newsroom feed, by keyword, company, ticker or subject.
- [Federal Register API](https://apify.com/insight.solutions/federal-register-api) — rules, proposed rules, notices and the Public Inspection desk with dockets, comment deadlines and CFR references.
- [Academic Papers Search API](https://apify.com/insight.solutions/academic-papers-api) — OpenAlex, Crossref, arXiv and PubMed in one row per paper: abstract, citations, open-access PDF, authors and venue.
- [RSS & Atom Feed Monitor](https://apify.com/insight.solutions/rss-feed-monitor) — any RSS, Atom or JSON feed (or an OPML file) in, only the new items out, with keyword filters and a webhook.
- [Website Change Monitor](https://apify.com/insight.solutions/website-change-monitor) — watch any pages, diff the text between runs, get change rows with added/removed lines, keyword alerts and a webhook.
- [Wikipedia & Wikidata API](https://apify.com/insight.solutions/wikipedia-api) — article text, search, daily pageviews and Wikidata entity facts, any language edition.

**Business, finance & jobs**

- [Congress & Insider Trades API](https://apify.com/insight.solutions/congress-insider-trades-api) — STOCK Act periodic transaction reports and SEC Form 4 insider trades in one schema.
- [Federal Contracts, Grants & Lobbying API](https://apify.com/insight.solutions/federal-contracts-grants-api) — SAM.gov opportunities, USAspending awards, Grants.gov notices and Senate lobbying filings in one schema.
- [SEC EDGAR API](https://apify.com/insight.solutions/sec-edgar-api) — filings, XBRL financials and full-text search by ticker or CIK.
- [Litigation Signals API — Lawsuits, Settlements & Investigations](https://apify.com/insight.solutions/litigation-signals-api) — lawsuits, settlements and investigations per public company from SEC 10-K, 10-Q and 8-K disclosures, press wires and SEC, FTC and DOJ notices, company-level only.
- [Funding Signals API — Rounds from SEC Form D, Wires & News](https://apify.com/insight.solutions/funding-signals-api) — who just raised money: one row per funding round from SEC Form D filings, press wires and Google News, with amount, round, investors, industry and state, company-level only.
- [Clinical Trials & FDA API](https://apify.com/insight.solutions/clinical-trials-fda-api) — ClinicalTrials.gov studies plus openFDA recalls, labels, approvals, 510(k)s and adverse-event reports.
- [Product & Vehicle Recalls API](https://apify.com/insight.solutions/product-recalls-api) — CPSC, NHTSA, FDA and USDA recalls, vehicle complaints and ratings, plus a VIN decoder.
- [Y Combinator Companies, Batches & Founders](https://apify.com/insight.solutions/yc-companies-directory) — the YC directory with founders and social links, filterable by batch, industry and hiring status.
- [Career Site Jobs API](https://apify.com/insight.solutions/ats-jobs-api) — jobs straight from Greenhouse, Lever, Ashby, Workable and 10+ other ATS career sites.
- [Workday Jobs API](https://apify.com/insight.solutions/workday-jobs-api) — every posting on any Workday career site, with facets, search, posted dates and full descriptions.
- [New Job Postings Monitor](https://apify.com/insight.solutions/job-postings-monitor) — new, closed and changed postings on the career sites you watch.
- [Hiring Signals API — Open Roles & Hiring Surge by Company](https://apify.com/insight.solutions/hiring-signals-api) — one row per company per run: open roles, what opened and closed, department and seniority breakdowns, and a hiring-surge flag.
- [Careers Page Jobs API — Open Roles from Any Company's Site](https://apify.com/insight.solutions/careers-page-jobs-api) — open roles from any company's own careers site: domain in, the platform recognised (Eightfold, Phenom, Jibe, iCIMS, Google, Amazon, 14 ATSs) or the site's structured data read, one row per job.
- [Remote Jobs API](https://apify.com/insight.solutions/remote-jobs-api) — RemoteOK, Remotive, We Work Remotely, Himalayas, Jobicy and more in one schema, deduplicated.
- [Shopify Products API](https://apify.com/insight.solutions/shopify-products-api) — any Shopify store's catalogue, variants, prices and stock signals.
- [WooCommerce Products API](https://apify.com/insight.solutions/woocommerce-products-api) — any WooCommerce store's catalogue, prices, variants and stock through its public Store API.
- [Price Tracker API — Prices, Stock & Changes from Any Retailer](https://apify.com/insight.solutions/price-tracker-api) — price, stock, list price and discount from any product URL, read from the page's structured data, with price-drop and restock rows between runs.
- [Shopify App Store API](https://apify.com/insight.solutions/shopify-app-store-api) — Shopify App Store listings by category, collection or developer: pricing plans, ratings and merchant reviews.
- [Luma Events API](https://apify.com/insight.solutions/luma-events-api) — upcoming Luma events by city, category or calendar: dates, venue, price, capacity and organiser calendar, no host names.
- [Shopify Store Monitor](https://apify.com/insight.solutions/shopify-store-monitor) — price drops, sales, restocks, sell-outs and new products on any Shopify store, one row per change.
- [Shopify Store Finder — Discover & Verify Stores by Niche](https://apify.com/insight.solutions/shopify-store-finder) — Shopify stores by niche and country, each verified on its own storefront, with product count, currency, country, price range and sample products.
- [Public Tenders API](https://apify.com/insight.solutions/public-tenders-api) — EU TED, UK Find a Tender and Contracts Finder notices by keyword, CPV code, country, stage and deadline.
- [Nonprofit & IRS 990 Lookup API](https://apify.com/insight.solutions/nonprofit-990-api) — search US nonprofits and get EIN, NTEE code and multi-year Form 990 financials.
- [OpenStreetMap Places API](https://apify.com/insight.solutions/osm-places-api) — businesses and points of interest by category and area from OpenStreetMap: name, address, coordinates, website, phone, opening hours.

**Apps & games**

- [App Store & Google Play Reviews API](https://apify.com/insight.solutions/app-reviews-api) — reviews from both stores with ratings, versions and developer replies.
- [App Store Top Charts & App Search API](https://apify.com/insight.solutions/app-charts-api) — Apple top charts by country and genre, plus app search and details.
- [App Store Keyword Rank Tracker](https://apify.com/insight.solutions/app-store-keyword-rank-tracker) — where any app ranks for any keyword on the App Store and Google Play, with rank changes and ASO suggestions.
- [Steam Reviews API](https://apify.com/insight.solutions/steam-reviews-api) — Steam reviews with playtime, helpfulness and game details.
- [Steam Game Data API](https://apify.com/insight.solutions/steam-store-stats-api) — prices, tags, review scores, live player counts and top charts.
- [Sports Scores & Schedules API](https://apify.com/insight.solutions/sports-scores-api) — scores, schedules, standings, teams and headlines for the NFL, NBA, MLB, NHL, soccer and more, no key.
- [App Store Monitor](https://apify.com/insight.solutions/app-store-monitor) — App Store and Google Play listings watched between runs: new versions with release notes, price, rating and listing changes, one row per change.

# Actor input Schema

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

Which list below is read. **podcast** reads `podcasts`, **youtube** reads `youtubeChannels`, **newsletter** reads `newsletters`, and **mixed** reads all three in one run. A list the chosen mode does not read is ignored, so switching modes never mixes sources by accident.

## `youtubeChannels` (type: `array`):

Channels to scan, one per line: a handle (`@LinusTechTips`), a channel URL (`https://www.youtube.com/@mkbhd`) or a channel ID (`UC…`). Each channel's newest uploads are read, and each video's **full** description is fetched — the upload list only carries a snippet.

## `podcasts` (type: `array`):

Shows to scan, one per line: a show name (`Huberman Lab`, resolved through Apple's search), an Apple Podcasts link or ID, or an RSS feed URL. Each show's newest episodes are read from its own feed, show notes in full.

## `newsletters` (type: `array`):

Substack publications to scan, one per line: a subdomain (`lenny`), a publication URL (`https://www.lennysnewsletter.com`) or a post link (its publication is read). Each publication's newest posts are read, body included.

## `maxItemsPerSource` (type: `integer`):

How many of the newest videos, episodes or posts are scanned per channel, show or publication. Each scanned item is one `item` row; each sponsor found in it is one `sponsorship` row.

## `since` (type: `string`):

Only scan items published on or after this date (`2026-09-01`, midnight UTC) or instant (`2026-09-01T00:00:00Z`). Older items are skipped and never billed. Leave empty for no date limit. A value that is not a date fails the run before any request, so a typo can never turn a dated run into a full one.

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

Optional filter: report only sponsorships whose brand or link matches one of these — a name (`AG1`, `Athletic Greens`, `Eight Sleep`) or a domain (`drinkag1.com`, `shopify.com`). Case and spacing are ignored. Every scanned item is still returned (see the next option), so coverage stays visible. Leave empty to report every brand.

## `includeItemsWithoutSponsors` (type: `boolean`):

Return an `item` row for every scanned video, episode or post, even when no sponsor was found in it — that is what makes "12 of 30 episodes were sponsored" countable. Turn off to receive (and pay for) only the items that carry a sponsorship.

## `resolveLinks` (type: `boolean`):

Follow each sponsor link — and each shortener such as `bit.ly` or `geni.us` — once, redirects only, to learn the domain it really lands on (`finalDomain`). Reads no page body, 5 seconds per link, results cached for the run. It costs time, not money.

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

How many channels, shows or publications are scanned at once. Each keeps its own proxy session, so a source that gets refused burns only its own exit IP.

## `maxRunSecs` (type: `integer`):

Wall-clock budget for the whole run. When it is reached the Actor stops fetching, keeps — and bills — every row it already wrote, and files a free `timeout` row for each source it never reached.

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

Apify datacenter proxy by default. YouTube is asked from it first, and a video YouTube refuses twice is retried once through a residential exit the Actor creates itself, so residential traffic is spent only on refusals. Apple's search goes through it; podcast feeds and Substack go direct first and use it only when a host refuses. Choosing residential here sends every YouTube request residential and turns the fallback off.

## Actor input object example

```json
{
  "mode": "podcast",
  "youtubeChannels": [
    "@LinusTechTips",
    "https://www.youtube.com/@mkbhd"
  ],
  "podcasts": [
    "Huberman Lab",
    "https://podcasts.apple.com/us/podcast/huberman-lab/id1545953110",
    "https://lexfridman.com/feed/podcast/"
  ],
  "newsletters": [
    "lenny",
    "https://www.platformer.news"
  ],
  "maxItemsPerSource": 10,
  "since": "2026-09-01",
  "brands": [
    "AG1",
    "betterhelp.com"
  ],
  "includeItemsWithoutSponsors": true,
  "resolveLinks": false,
  "maxConcurrency": 3,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Sponsorships read from public video descriptions, podcast show notes and newsletter posts, in one schema, plus item, source and diagnostic rows. Delivered as JSON items in the default dataset.

# 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": "podcast",
    "youtubeChannels": [],
    "podcasts": [
        "Huberman Lab",
        "Lex Fridman Podcast",
        "The Tim Ferriss Show"
    ],
    "newsletters": [],
    "maxItemsPerSource": 10,
    "brands": [],
    "includeItemsWithoutSponsors": true,
    "resolveLinks": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("insight.solutions/sponsorship-intelligence-api").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": "podcast",
    "youtubeChannels": [],
    "podcasts": [
        "Huberman Lab",
        "Lex Fridman Podcast",
        "The Tim Ferriss Show",
    ],
    "newsletters": [],
    "maxItemsPerSource": 10,
    "brands": [],
    "includeItemsWithoutSponsors": True,
    "resolveLinks": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("insight.solutions/sponsorship-intelligence-api").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": "podcast",
  "youtubeChannels": [],
  "podcasts": [
    "Huberman Lab",
    "Lex Fridman Podcast",
    "The Tim Ferriss Show"
  ],
  "newsletters": [],
  "maxItemsPerSource": 10,
  "brands": [],
  "includeItemsWithoutSponsors": true,
  "resolveLinks": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call insight.solutions/sponsorship-intelligence-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,insight.solutions/sponsorship-intelligence-api"
        }
    }
}
```

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/cEmWdVBGJyEmshg41/builds/9KtfVvpnbE5SAT0I6/openapi.json