youtube-channel-business-email

Files (4)

• SKILL.md
• extract-channel-about.py · scripts/
• extract-emails-from-text.py · scripts/
• normalize-channel-input.py · scripts/

SKILL.md (first lines)

# YouTube — Channel Business Email & Contact Extractor

> Input: a YouTube channel id (`UCxxx`), handle (`@name`), or channel URL. Output: structured channel metadata (id, name, counters, country, joined date, external links classified by kind) plus the channel's business email if it can be found on the About page description or on any linked personal/business website.

## Language

All process output to user (progress updates, process notifications) follows the user's language.

## Objective

Extract a YouTube channel's business inquiry email together with the channel's About metadata and outbound link list, prioritising what is already publicly displayed on the channel's About page; if no email is visible there, walk the channel's own outbound links (personal site, business site, link aggregator) to recover an email that the creator publishes on a site they control.

## Prerequisites

- Target page is already open in the browser: `https://www.youtube.com/{@handle|channel/UCxxx}/about`
- No login is required for description and link extraction; running the browser while signed in to YouTube does not change what is returned by this Skill.

## Pre-execution Checks

### 1. Tool Readiness

If browser-act has been confirmed available in the current session → skip this step.

Invoke `browser-act` via Skill tool to load usage. If installation or configuration issues arise, follow its guidance to resolve then retry.

## Capability Components

> This Skill's operational boundary = what the user can manually do in their browser. It only reads data already displayed to the user on the page, never bypassing authentication or access controls. Its role is equivalent to copy-pasting on the user's behalf — the data is already on screen, automation merely saves time. JS code is encapsulated in Python files under the `scripts/` directory; each `.py` script prints a self-contained JS snippet to stdout. To execute that snippet in the browser, hand it to browser-act's `eval` subcommand via bash command substitution: `browser-act --session <session-name> eval "$(python scripts/xxx.py {params})"`. The outer `$(...)` is bash syntax; use the bash tool to run it. Pure-Python scripts that already emit a JSON result on stdout (e.g. `normalize-channel-input.py`, `extract-emails-from-text.py`) are invoked directly: `python scripts/xxx.py {params}` — do NOT wrap them in `browser-act eval`.

### API: normalize a channel input into a canonical /about URL

`python scripts/normalize-channel-input.py '{channel-input}'`

Parameters:
- `{channel-input}`: a channel id (`UCxxxxxxxxxxxxxxxxxxxxxx`, 24 chars starting with `UC`), a handle (`@name`), a bare handle (`name`), or any channel URL (`https://www.youtube.com/@name`, `https://www.youtube.com/channel/UCxxx`, `https://www.youtube.com/c/legacy`, `https://www.youtube.com/user/legacy`). Trailing path segments and querystrings are stripped.

Output example:
```json
{
  "about_url": "https://www.youtube.com/@example/about",   // canonical URL to navigate to before extraction
  "input_type": "handle",                                  // one of: handle | channel_id | channel_url | legacy_custom_url | bare_handle | raw_url
  "value": "@example"                                      // normalised value (handle with @ prefix, or channel id, or raw url)
}
```

On unrecognised input the script returns `{"error": true, "message": "unrecognized input: ..."}`.

### DOM: extract channel About metadata + emails from description

Run from the channel's `/about` view (after `navigate` + `wait stable`). Reads `window.ytInitialData.aboutChannelViewModel` and pulls the description, full counter set, channel id, canonical URL, the resolved outbound links (with the YouTube redirect wrapper unwrapped), and any email addresses already present in the description text.

Extract: `browser-act --session <session-name> eval "$(python scripts/extract-channel-about.py)"`

Output example:
```json
{
  "channel_id": "UCxxxxxxxxxxxxxxxxxxxxxx",                // YouTube channel id (UCxxx)
  "channel_name": "Channel Display Name",                  // display name from channel metadata
  "canonical_channel_url": "http://www.youtube.com/@example", // canonical channel URL reported by YouTube
  "description": "Short bio line ...\n\nbusiness@example.com\n\nCity", // full About description text
  "country": "United States",                              // country shown on the About panel (localised text)
  "subscriber_count_text": "21M subscribers",              // raw display text (locale-formatted)
  "view_count_text": "5,455,901,172 views",                // raw display text (locale-formatted)
  "video_count_text": "1,831 videos",                      // raw display text (locale-formatted)
  "joined_date_text": "Joined Mar 21, 2008",               // raw display text (locale-formatted)
  "has_business_email_reveal_button": true,                // whether the "View email address" button is exposed on the page
  "bypass_business_email_captcha": false,                  // whether the current viewer can skip the email reveal captcha
  "emails_in_description": ["business@example.com"],       // emails matched in the description text; empty array when none
  "links": [                                               // outbound links with YouTube /redirect wrappers unwrapped
    {"title": "Twitter", "display": "twitter.com/example", "url": "http://twitter.com/example"}
  ]
}
```

On failure (page is not a channel `/about` view, `ytInitialData` missing, or `aboutChannelViewModel` not present), the script returns `{"error": true, "message": "..."}`.

### API: extract emails from arbitrary text + classify a URL by kind

`python scripts/extract-emails-from-text.py [--text '{text}' | --text-file {path}] [--classify-url '{url}']`

Parameters:
- `--text`: raw text to scan for email addresses (plain, markdown, or HTML)
- `--text-file`: path to a UTF-8 text file to scan for email addresses
- `--classify-url`: URL to classify into `social`, `link_aggregator`, or `personal_or_business` (used to decide which outbound links are worth fetching during email recovery)

Output example (with `--text` and `--classify-url`):
```json
{
  "classification": {
    "kind": "personal_or_business",          // social | link_aggregator | personal_or_business | invalid
    "domain": "example.com",
    "url": "https://example.com/"
  },
  "emails": ["info@example.com"]             // deduplicated, image/file extensions filtered out, obfuscated forms like name [at] brand [dot] io are recovered
}
```

Without any argument the script returns `{"error": true, "message": "provide --text, --text-file, or --classify-url"}`.

### Composite: end-to-end channel-to-business-email lookup

Cross-page composite: input normalisation → navigation → About extraction → optional follow of one or more non-social outbound links to recover an email when the description had none.

Before the loop, ensure a scratch directory exists for the markdown dumps used in step 6: `mkdir -p tmp` (run once per batch, not per channel).

1. Normalise the input:
   `python scripts/normalize-channel-input.py '{channel-input}'` — read `about_url` from stdout.
2. Navigate the browser session to that URL and wait for it to render:
   `browser-act --session <session-name> navigate {about_url}` → `browser-act --session <session-name> wait stable --timeout 12000` (a `Timed out waiting for page readiness` here is recoverable — proceed if the URL and title reflect the channel; check Known Limitations).
3. Pull the channel About payload:
   `browser-act --session <session-name> eval "$(python scripts/extract-channel-about.py)"`
4. If `emails_in_description` is non-empty, set `business_email = emails_in_description[0]` and `email_source = "description"`. Stop and emit the result.
5. Otherwise classify each link to decide which outbound URLs to walk; skip `social` links (Twitter/Instagram/TikTok/Facebook/etc. — they require login and are unreliable to scrape):
   For each `link.url` in `links`:
   `python scripts/extract-emails-from-text.py --classify-url '{link.url}'`
6. For every link classified as `personal_or_business` or `link_aggregator`, fetch its rendered text and look for an email; stop at the first match:
   - `browser-act stealth-extract '{link.url}' --content-type markdown > tmp/site.md`
   - `python scripts/extract-emails-from-text.py --text-file tmp/site.md`
   - If the result has non-empty `emails`, set `business_email = emails[0]`, `email_source = "linked_website:{classification.domain}"` and stop.

From browser-act/skills, MIT.

More from browser-act/skills