# Fox News Videos Scraper (`scrapyx/foxnews-videos-scraper`) Actor

Collects Fox News video metadata: title, description, duration, publish date, thumbnail, direct content URL, expiry and optional topic tags. Reads Fox's own video sitemaps, about 670,000 videos in 140 partitions, with date, duration and keyword filters.

- **URL**: https://apify.com/scrapyx/foxnews-videos-scraper.md
- **Developed by:** [Ibnu Adzim](https://apify.com/scrapyx) (community)
- **Categories:** News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Fox News Videos Scraper

Collects video metadata from **foxnews.com**: title, description, duration,
publish date, thumbnail, the direct content URL, and optionally the topic and
show tags.

It reads Fox's own video sitemaps, which carry **every field of a video's
record inline**. That means a run of any size costs roughly **one request per
4,825 videos** and fetches no video pages at all, unless you ask for topic
tags. The archive holds about **670,000 videos across 140 partitions**.

No login, no API key, no browser. Plain HTTP, Python only.

### What you get

One dataset, three kinds of row, told apart by `recordType`.

**`VIDEO`** — one per video: page URL, title, description, thumbnail, direct
content URL, duration in both seconds and ISO 8601, publish date, and Fox's own
subscription and live flags. With topic tags on, also the show and topic tags
and the embed URL.

**`SEARCH_SUMMARY`** — one per run: how many videos were discovered, how many
came back, how many sitemap partitions were read out of how many exist, whether
the archive walk ended early, how many duplicates were removed, and how many
rows each filter dropped.

**`ERROR`** — one per URL that failed, so a failure can never look like an
empty result.

### Examples

The fifty newest videos, two requests total:

```json
{ "maxItems": 50 }
```

Full episodes only, ten minutes or longer:

```json
{ "maxItems": 100, "minDurationSeconds": 600, "includeArchive": true, "maxArchivePages": 3 }
```

Short clips from a date range:

```json
{
  "maxItems": 200,
  "maxDurationSeconds": 120,
  "dateFrom": "2026-08-01",
  "dateTo": "2026-08-31",
  "includeArchive": true,
  "maxArchivePages": 3
}
```

With topic and show tags, which cost one request per video:

```json
{ "maxItems": 25, "includeTopics": true }
```

### Limits, stated plainly

**Topic tags need the video page.** The sitemaps have no field for them, so
`includeTopics` fetches each video's page. That is the only setting that turns
one request per thousands of videos into one request per video. Everything
else about a video is returned either way.

**Expiry dates are rare.** Fox supplies `expiration_date` on only about 1.7% of
entries, measured across a full 4,825-entry partition. The field is passed
through when present and left empty otherwise, never filled with a guess.

**Subscription and live flags were uniform.** Across a full partition, every
entry reported `no` for both. They are passed through verbatim because they are
upstream's own flags, but no filter is offered on them: a filter whose field has
one observed value looks like a choice and never changes a result.

**The keyword filter runs here, not at Fox.** Fox exposes no video search
parameter, so keywords narrow what a run already retrieved. To search wider,
widen the run with `includeArchive` and `maxArchivePages`.

**The duration filter is exact.** Duration is an integer Fox supplies for every
entry, so nothing is estimated there.

**Undated videos are dropped inside a date range.** If a date bound is set and
a video carries no usable date, it is excluded rather than included on a guess.

**Partitions are large.** Each is roughly 4,825 videos in a multi-megabyte
file. One is only fetched when the newest slice cannot already satisfy your
request, and a partition falling entirely before your start date ends the walk.

**Articles are a separate Actor.** Fox's article pages carry a body, author and
word count that videos have no equivalent of, so they have their own scraper
rather than being folded in here with half the columns empty.

### Blocking and proxies

No bot-mitigation gate was found on any Fox News surface during development:
the sitemaps and the video pages answered cold across four different TLS
fingerprints, with no challenge, no cookie and no token. The Actor defaults to
Apify's shared **datacenter** proxy, included in your plan at no extra cost.
Residential is available in the proxy editor if you ever need it; Apify bills
it per gigabyte.

One quirk worth knowing, because it looks like a block and is not: Fox's video
sitemap answers a partition that does not exist with **HTTP 502 and an eight
byte body**, where its article sitemap would answer 404. This Actor recognises
that exact response as the end of the archive and stops cleanly, instead of
retrying a page that can never exist and reporting a transport failure.

### Politeness

`robots.txt` at foxnews.com sets no `Crawl-delay` and names no AI-crawler
group. It disallows the site search, the video search, the wires and the
printer-friendly paths, none of which this Actor touches: it reads the video
sitemaps that `robots.txt` itself advertises, and public video pages. Request
starts are paced by `minRequestInterval`, which defaults to a quarter second.

# Actor input Schema

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

How many videos to return, newest first, after the date, duration and keyword filters. The video sitemap carries every field of a video's record inline, so a run of any size here costs one request per roughly 4,825 videos unless 'Include topic tags' is on.

## `includeArchive` (type: `boolean`):

Walk Fox's older video sitemap partitions as well as the newest one. The archive holds about 670,000 videos in 140 partitions of roughly 4,825, newest first. Each partition is a multi-megabyte download, so one is only fetched when the newest partition cannot already fill your request, and partitions falling entirely before 'Published from' end the walk.

## `maxArchivePages` (type: `integer`):

How many sitemap partitions to download when 'Include archive' is on, newest first. This is the real cost control for deep runs.

## `includeTopics` (type: `boolean`):

Fetch each video's own page to add its topic and show tags (for example 'U.S.', 'Shows', 'On Air') and its embed URL. These exist only on the video page, not in the sitemap, so this costs one request per video and is off by default. Everything else about a video is returned either way.

## `dateFrom` (type: `string`):

Optional lower bound on the publish date, inclusive, as YYYY-MM-DD. Videos with no usable date are excluded whenever a bound is set.

## `dateTo` (type: `string`):

Optional upper bound on the publish date, inclusive, as YYYY-MM-DD.

## `minDurationSeconds` (type: `integer`):

Optional. Keep only videos at least this long. Duration is supplied by Fox for every video in the sitemap, so this filter is exact rather than estimated. Use it to separate short clips from full episodes.

## `maxDurationSeconds` (type: `integer`):

Optional. Keep only videos no longer than this.

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

Optional. Keep only videos whose title, description or topic tags contain one of these words, matched case-insensitively. This is filtering done by this Actor after fetching, not a search sent to Fox News, which offers no video search parameter. To search wider, widen the run with 'Include archive'.

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

Upper bound on requests in flight at once.

## `minRequestInterval` (type: `number`):

Shared pacing floor across every request this run makes. Fox News sets no Crawl-delay in robots.txt, so this default is this portfolio's own politeness baseline rather than a site requirement.

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

Apify Proxy on the shared datacenter pool. That is the default because it is included in your plan at no extra cost and this target needs nothing more: no bot-mitigation gate was seen on any Fox News surface during testing. Switch the group here to Residential only if you start seeing blocks, since Apify bills residential traffic per gigabyte.

## Actor input object example

```json
{
  "maxItems": 50,
  "includeArchive": false,
  "maxArchivePages": 1,
  "includeTopics": false,
  "keywords": [],
  "maxConcurrency": 5,
  "minRequestInterval": 0.25,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `items` (type: `string`):

One row per scraped record. See the dataset's default view for field definitions.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapyx/foxnews-videos-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapyx/foxnews-videos-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 '{}' |
apify call scrapyx/foxnews-videos-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapyx/foxnews-videos-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/kWw65eb258aAl7gEz/builds/pi02GkdwUsdFjHQKS/openapi.json