# New York Times Scraper (`scrapesmith/new-york-times-scraper`) Actor

Extract full article text, authors, dates, and metadata from nytimes.com. Covers all sections including The Athletic. Two modes: scrape article URLs or fetch latest headlines by section. 180+ articles/min, no browser, structured JSON output.

- **URL**: https://apify.com/scrapesmith/new-york-times-scraper.md
- **Developed by:** [Scrape Smith](https://apify.com/scrapesmith) (community)
- **Categories:** News, Developer tools, Automation
- **Stats:** 15 total users, 9 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## New York Times Scraper — Full Articles, Headlines & Archives

Extract **full article text**, headlines, authors, dates, images, and categories from the New York Times. Covers all NYT sections including The Athletic, opinion, briefings, and 24+ topic feeds.

### Why use this scraper?

- **Full article content** — not just headlines or snippets. Extracts the complete article body text, typically 300–2,000 words per article.
- **All sections supported** — news, politics, business, technology, sports, opinion, The Athletic, arts, travel, food, and 15+ more.
- **Two modes** — scrape specific article URLs, or fetch the latest articles from any section.
- **Fast** — processes 180+ articles per minute with concurrent extraction.
- **Structured output** — clean JSON with 13 fields per article. Export to JSON, CSV, Excel, or connect via API.

### Modes

#### Article Mode (default)

Paste one or more NYTimes article URLs. The scraper extracts the full text and metadata from each.

**Input example:**
```json
{
  "mode": "article",
  "urls": [
    "https://www.nytimes.com/2026/07/08/business/economy/imf-world-economy-inflation.html",
    "https://www.nytimes.com/athletic/7428802/2026/07/07/argentina-world-cup/"
  ]
}
````

#### Latest Mode

Fetch the most recent articles from any NYT section feed. Enable `extractContent` to also get the full article text (otherwise returns headlines and metadata only).

**Input example:**

```json
{
  "mode": "latest",
  "section": "technology",
  "limit": 25,
  "extractContent": true
}
```

**Available sections:** homepage, world, us, politics, nyregion, business, technology, science, health, sports, arts, books, movies, theater, travel, style, food, opinion, sundayreview, realestate, magazine, education, media, obituaries, jobs.

### Input Parameters

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `mode` | string | `"article"` | `"article"` — scrape specific URLs. `"latest"` — fetch recent articles from an RSS section. |
| `urls` | string\[] | `[]` | NYTimes article URLs to scrape (article mode). Supports regular articles, The Athletic, briefings, opinion, and more. |
| `section` | string | `"homepage"` | Which NYT section to fetch in latest mode. See list above. |
| `limit` | integer | `25` | Max number of articles to return in latest mode (1–100). |
| `extractContent` | boolean | `false` | In latest mode, also fetch each article's full text. Without this, you get headlines + metadata only. |

### Output Fields

Each result includes:

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | Article URL |
| `source` | string | Always "New York Times" |
| `title` | string | Article headline |
| `description` | string | Article summary |
| `content` | string | Full article body text |
| `image` | string | Featured image URL |
| `language` | string | Language code (`"en"`) |
| `word_count` | integer | Number of words in the article |
| `published_date` | string | Publication timestamp (ISO 8601) |
| `modified_date` | string | Last modified timestamp |
| `authors` | string\[] | List of author names |
| `categories` | string | Section/topic (e.g., "Business", "Technology") |
| `tags` | string | Associated keywords |

**Example output:**

```json
{
  "url": "https://www.nytimes.com/2026/07/08/business/economy/imf-world-economy-inflation.html",
  "source": "New York Times",
  "title": "Global Economic Output Looks Slower for 2026, IMF Says",
  "description": "The I.M.F. projected world output growth would fall to 3 percent...",
  "content": "The global economy is set to slow sharply in 2026 after the war with Iran disrupted energy supply chains...",
  "image": "https://static01.nyt.com/images/2026/07/08/multimedia/08dc-globalecon-hjcg.jpg",
  "language": "en",
  "word_count": 624,
  "published_date": "2026-07-08T13:00:12.000Z",
  "modified_date": "2026-07-08T15:30:00.000Z",
  "authors": ["Alan Rappeport"],
  "categories": "Business",
  "tags": ""
}
```

### Use Cases

- **News monitoring** — track NYT coverage of your industry, company, or topic.
- **Media research** — analyze article length, authorship patterns, publication frequency.
- **Content aggregation** — build news feeds, newsletters, or dashboards with NYT data.
- **Sentiment analysis** — feed article text into NLP pipelines for tone and topic analysis.
- **Academic research** — collect articles for journalism studies, political science, economics research.
- **SEO & PR monitoring** — track when your brand or competitors are mentioned.

### Performance

- **Speed:** 180+ articles per minute (concurrent extraction).
- **Success rate:** 99%+ on standard NYT article URLs.
- **Memory:** 512 MB (no browser required).
- **Supported content:** Regular articles, The Athletic, opinion pieces, briefings, podcasts (transcript/description).

### Integration

Use via the Apify API, JavaScript/Python client, CLI, or connect to Google Sheets, Zapier, Make, Slack, and other integrations. Schedule runs to automatically collect new articles on a recurring basis.

### Pricing

This actor is pay-per-result. You are charged for each article extracted. Free users get 10 articles per run. See the Pricing tab for details.

# Actor input Schema

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

"article" to scrape specific URLs, "latest" to fetch recent articles from an RSS section feed.

## `urls` (type: `array`):

List of NYTimes article URLs to scrape (article mode).

## `section` (type: `string`):

Which NYT section to fetch in latest mode.

## `limit` (type: `integer`):

Maximum number of articles to return in latest mode.

## `extractContent` (type: `boolean`):

In latest mode, also fetch each article URL to extract the full article text.

## Actor input object example

```json
{
  "mode": "article",
  "section": "homepage",
  "limit": 25,
  "extractContent": false
}
```

# 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("scrapesmith/new-york-times-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("scrapesmith/new-york-times-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 scrapesmith/new-york-times-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapesmith/new-york-times-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "New York Times Scraper",
        "description": "Extract full article text, authors, dates, and metadata from nytimes.com. Covers all sections including The Athletic. Two modes: scrape article URLs or fetch latest headlines by section. 180+ articles/min, no browser, structured JSON output.",
        "version": "0.0",
        "x-build-id": "W3V1J5hvgjIe9faEm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~new-york-times-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-new-york-times-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapesmith~new-york-times-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-new-york-times-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapesmith~new-york-times-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-new-york-times-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "article",
                            "latest"
                        ],
                        "type": "string",
                        "description": "\"article\" to scrape specific URLs, \"latest\" to fetch recent articles from an RSS section feed.",
                        "default": "article"
                    },
                    "urls": {
                        "title": "Article URLs",
                        "type": "array",
                        "description": "List of NYTimes article URLs to scrape (article mode).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "section": {
                        "title": "Section",
                        "enum": [
                            "homepage",
                            "world",
                            "us",
                            "politics",
                            "nyregion",
                            "business",
                            "technology",
                            "science",
                            "health",
                            "sports",
                            "arts",
                            "books",
                            "movies",
                            "theater",
                            "travel",
                            "style",
                            "food",
                            "opinion",
                            "realestate",
                            "magazine",
                            "education",
                            "obituaries"
                        ],
                        "type": "string",
                        "description": "Which NYT section to fetch in latest mode.",
                        "default": "homepage"
                    },
                    "limit": {
                        "title": "Limit",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of articles to return in latest mode.",
                        "default": 25
                    },
                    "extractContent": {
                        "title": "Extract Full Content",
                        "type": "boolean",
                        "description": "In latest mode, also fetch each article URL to extract the full article text.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
