# YT Jobs Scraper - Full Job Details, Salary & Channel Stats (`gio21/ytjobs-scraper`) Actor

Scrape YouTube job listings from ytjobs.co: salary, job type, channel stats, full description, skills, experience and dates. Filter by role, keyword, job type, location. $0.004/job.

- **URL**: https://apify.com/gio21/ytjobs-scraper.md
- **Developed by:** [Gio](https://apify.com/gio21) (community)
- **Categories:** Jobs
- **Features:** Limited permissions
- **Stats:** 31 total users, 14 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 job scrapeds

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?

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

## YT Jobs Scraper - Full Job Details, Salary & Channel Stats

### Why use this scraper

YTJobs.co is the main dedicated job board for YouTube-industry roles: video
editors, thumbnail designers, scriptwriters, channel managers and more. It
has no public API, and browsing it by hand to track new postings for a
role, a niche or a salary range does not scale past a handful of jobs a
week. Recruiters, agencies and creators hiring for their channel all hit
the same wall: no structured way to pull listings in bulk or monitor for
new ones.

**YT Jobs Scraper** returns every listing matching your filters as
structured JSON, including the fields that only show up once you open a
job's own page: full description, requirements, required skills, minimum
experience, languages and posting/expiry dates, not just the title and
link you'd get from a shallow crawl.

### Overview

The actor reads the YTJobs.co job board, filtered by role, keyword, job
type and location type, and returns one record per listing. With
`includeDetails` enabled (the default), it also opens each job's own page
for the full description, requirements, skills and dates, one extra
request per job. You are charged **$0.004 per job scraped**, whether or
not full details were fetched for it.

### Supported inputs

- **role** (optional, default `all`) - filter by role category: `all`,
  `video-editor`, `creative-director`, `thumbnail-designer`,
  `channel-manager`, `youtube-strategist`, `scriptwriter`,
  `youtube-producer` or `other`.
- **keyword** (optional) - free-text match against job title and channel
  name, e.g. `"gaming"` or `"documentary"`.
- **jobType** (optional, default `all`) - `full-time` (salary shown per
  year), `part-time` (per hour) or `per-project`.
- **locationType** (optional, default `all`) - `remote`, `onsite` or
  `hybrid`. Most YTJobs.co listings are remote.
- **includeDetails** (optional, default `true`) - fetch the full job page
  for each result (description, requirements, skills, languages, posting
  and expiry dates). Set to `false` for a faster, lighter run that returns
  only the board-level fields.
- **maxItems** (optional, default 50, max 600) - hard cap on jobs returned.

### Use cases

- **Recruiters and agencies sourcing for YouTube roles.** Pull every
  open `video-editor` or `thumbnail-designer` listing to see going rates
  and requirements before making an offer.
- **Freelancers tracking new work.** Monitor a role and location-type
  filter on a schedule to catch new postings the day they go up.
- **Creators benchmarking a hire.** Before posting your own job, pull
  comparable listings to see what salary range and skill list similar
  channels are asking for.
- **Market research on the creator economy.** Aggregate salary ranges,
  required skills and channel subscriber counts across hundreds of
  listings to map how the YouTube production job market is moving.
- **AI sourcing agents.** Feed structured job data into an assistant that
  matches candidates to open roles or drafts outreach messages.

### How it works

The actor requests the YTJobs.co job listing pages for the chosen filters
and reads each card: title, role, job type, salary range, location type
and the hiring channel's basic stats. When `includeDetails` is enabled, it
then opens each individual job's own page to pull the fields the board
listing doesn't show: full description, requirements, ideal-candidate
notes, required skills, minimum experience, required languages and the
posting and expiry dates.

### Input configuration

**1. All open video-editor roles**

```json
{
  "role": "video-editor",
  "maxItems": 50
}
```

**2. Remote, full-time roles matching a keyword**

```json
{
  "keyword": "gaming",
  "jobType": "full-time",
  "locationType": "remote",
  "maxItems": 30
}
```

**3. Fast board-level scan, no per-job detail fetch**

```json
{
  "role": "all",
  "includeDetails": false,
  "maxItems": 200
}
```

### Output sample

Real output from a production run against ytjobs.co (September 2026),
fields trimmed for length:

```json
[
  {
    "id": "44806",
    "title": "Social Media Producer (Personal Brand)",
    "url": "https://ytjobs.co/job/44806",
    "role": "Other",
    "jobType": "Full-time",
    "salaryPeriod": "per year",
    "minSalary": 90000,
    "maxSalary": 115000,
    "locationType": "Remote",
    "location": null,
    "easyApply": true,
    "isFeatured": false,
    "status": "active",
    "companyName": "Media Engineering",
    "company": {
      "id": "141901",
      "name": "Media Engineering",
      "isVerified": true,
      "subscribers": "0",
      "totalViews": "0",
      "youtubeUrl": "https://youtube.com/channel/"
    },
    "subscribers": "0",
    "styles": ["IRL", "Vlog", "Tutorial", "Behind the scenes", "Q&A", "How-to"],
    "categories": ["Travel & Events", "People & Blogs", "Entertainment", "Marketing"],
    "descriptionText": "About Gloria. Gloria Zhu is a San Francisco founder and investor building her personal brand in public ahead of HUES, her beverage brand launching in 2027...",
    "createdAt": "09/28/2026",
    "startsAt": "within a month",
    "expiresAt": "2026-11-29T17:37",
    "minimumExperience": 3,
    "videoType": "all",
    "requiredLanguages": ["English"],
    "skills": ["Adobe After Effects", "Adobe Premiere Pro", "CapCut", "ChatGPT", "Descript", "Frame.io"],
    "referralBonus": 1000,
    "scrapedAt": "2026-09-28T19:09:20.284Z"
  }
]
```

### Key output fields

| Field | Type | Description |
|-------|------|-------------|
| `id` / `url` | string | YTJobs.co job ID and canonical job page URL. |
| `title` / `role` | string | Job title and role category. |
| `jobType` / `salaryPeriod` | string | Employment type and how salary is expressed (`per year`, `per hour`). |
| `minSalary` / `maxSalary` | number | Salary range in USD, as posted. |
| `locationType` / `location` | string | null | Remote, on-site or hybrid, plus a location string when the poster set one. |
| `easyApply` / `isFeatured` | boolean | Whether the listing supports one-click apply, and whether it's a featured post. |
| `status` | string | Listing status (e.g. `active`). |
| `companyName` / `company` | string / object | Hiring channel's name and a stats object (subscribers, total views, verification, YouTube URL). |
| `styles` / `categories` | array | Content styles and YouTube categories the hiring channel produces. |
| `descriptionText` | string | Full job description, plain text (only with `includeDetails: true`). |
| `createdAt` / `startsAt` / `expiresAt` | string | Posting date, expected start, and expiry date/time. |
| `minimumExperience` | number | Minimum years of experience requested. |
| `requiredLanguages` | array | Languages the posting requires. |
| `skills` | array | Named tools and skills the posting lists (editing software, AI tools, etc). |
| `referralBonus` | number | null | Referral bonus in USD, when the poster set one. |
| `scrapedAt` | string | Scrape timestamp. |

### Pricing

Pay-per-event, one charge type:

| Event | Price |
|-------|-------|
| Job scraped | $0.004 |

That is **$4.00 per 1,000 jobs** scraped, with full details included at
no extra charge when `includeDetails` is on.

### What makes this richer than the competition

No other actor on the Apify Store scrapes ytjobs.co directly (checked
September 2026, searching the Store for "ytjobs" and "youtube jobs"): the
practical alternative today is browsing the board by hand, or running a
generic job-aggregator scraper that does not reach a niche board like this
one at all. Since there is no direct competitor to compare numbers
against, the honest differentiator is depth: this actor returns the full
job page, not just the board card, in the same run, at one flat price per
job, including salary range, hiring-channel stats, required skills,
minimum experience and posting/expiry dates that a board-level-only scrape
would miss entirely.

### Notes & limitations

- **`location` is often `null`.** Most YTJobs.co listings are remote and
  do not set a specific location string; the field reflects what the
  poster actually filled in.
- **Channel stats can read `0`.** Some hiring channels have an
  unlinked or unpopulated YouTube profile on YTJobs.co, in which case
  `subscribers` and `totalViews` come back as `"0"` rather than a
  fabricated number.
- **`includeDetails: false` returns fewer fields.** Skipping the per-job
  detail fetch is faster and still billed at the same $0.004 per job, but
  you won't get `descriptionText`, `skills`, `requiredLanguages`,
  `minimumExperience` or the posting/expiry dates.
- **Listings expire.** `status` and `expiresAt` reflect what YTJobs.co
  shows at scrape time; a listing can close between runs.

### FAQ

**Do I need a YTJobs.co account to use this?**
No. The actor reads public job listings; no login or credentials are
required.

**What's the difference between board-level and full-detail data?**
Board-level data (title, salary range, role, job type) comes from the
listing page itself. Full details (`descriptionText`, `skills`,
`requiredLanguages`, `minimumExperience`, dates) require opening the job's
own page, which happens automatically when `includeDetails` is `true`
(the default).

**Can I filter by salary range?**
Not as a built-in input field. Every listing returns `minSalary` and
`maxSalary`, so filter after the run, or set `maxItems` high and post-
process the dataset.

**Why is `location` sometimes empty?**
Most listings on YTJobs.co are remote with no location field set by the
poster. The actor returns exactly what's on the page, `null` when it's
not there.

**How much does a 500-job run cost?**
$2.00 at $0.004 per job scraped, including full details.

**Can I schedule this to run automatically?**
Yes, use Apify's built-in [schedules](https://docs.apify.com/platform/schedules)
to catch new postings on a recurring basis.

### For AI Agents & LLM Apps

This actor is callable from any MCP-compatible AI assistant through the
[Apify MCP server](https://mcp.apify.com), and directly from code through
the Apify API.

**Via MCP** (`mcp.apify.com`): add the Apify MCP server to your AI
assistant and call the `gio21/ytjobs-scraper` actor by name with `role`,
`keyword` or `jobType`.

**Via API** (`run-sync-get-dataset-items`):

```bash
curl "https://api.apify.com/v2/acts/gio21~ytjobs-scraper/run-sync-get-dataset-items?token=<APIFY_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"role": "video-editor", "jobType": "full-time", "maxItems": 50}'
```

### Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by,
or sponsored by YTJobs.co or any of its subsidiaries. All trademarks
mentioned are the property of their respective owners.

### SEO Keywords

ytjobs scraper, youtube jobs scraper, youtube industry jobs api, video editor jobs scraper, youtube job board data, creator economy jobs scraper

# Actor input Schema

## `role` (type: `string`):

Filter jobs by role category. Use "all" to get every role.

## `keyword` (type: `string`):

Optional keyword matched against job title and channel name, e.g. "gaming" or "documentary".

## `jobType` (type: `string`):

Filter by employment type: full-time (salary per year), part-time (per hour) or per-project.

## `locationType` (type: `string`):

Filter by work location type. Most YT Jobs listings are remote.

## `includeDetails` (type: `boolean`):

Fetch the full job page for each result: description, requirements, skills, languages, posting and expiry dates. One extra request per job.

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

Maximum number of jobs to return (paginates automatically).

## Actor input object example

```json
{
  "role": "all",
  "jobType": "all",
  "locationType": "all",
  "includeDetails": true,
  "maxItems": 50
}
```

# 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 = {
    "role": "all",
    "jobType": "all",
    "locationType": "all",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("gio21/ytjobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "role": "all",
    "jobType": "all",
    "locationType": "all",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("gio21/ytjobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "role": "all",
  "jobType": "all",
  "locationType": "all",
  "maxItems": 50
}' |
apify call gio21/ytjobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gio21/ytjobs-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/wHEN3vbViEdeqpOS2/builds/C1kfa3q176oW3Mzcq/openapi.json