# TechCrunch Scraper (`scrapelabmax/techcrunch-scraper`) Actor

Scrape full-text TechCrunch articles as clean markdown, text or HTML. Search by keyword, filter by category, author, tag and date, or enrich a list of article URLs. Fast (no browser), MCP-ready and built for RAG pipelines.

- **URL**: https://apify.com/scrapelabmax/techcrunch-scraper.md
- **Developed by:** [Scrapelab Max](https://apify.com/scrapelabmax) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 articles

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

## TechCrunch Scraper: full-text tech news for analysts, RAG and MCP agents

**TechCrunch Scraper** returns structured, **full-text TechCrunch articles** as clean markdown, plain text or HTML. You can search by keyword, follow a category, author or tag, limit by date range, or enrich a list of article URLs you already have. It covers **tech news, startup funding news, AI, fintech and venture**, and the output drops straight into a spreadsheet, a vector database (**RAG**) or an AI agent through Apify's **MCP** server.

### What does TechCrunch Scraper do?

- **Keyword search.** Each keyword runs as its own TechCrunch search, for example `"anthropic"` or `"series b"`.
- **Category, author and tag feeds.** Follow `artificial-intelligence`, `fintech` or `venture`, a reporter, or a tag like `openai`.
- **Date ranges.** Use absolute dates (`2026-10-01`) or relative ones (`7 days`, `2 weeks`, `1 month`, `yesterday`).
- **URL list enrichment.** Paste TechCrunch article links and get back the full article with metadata.
- **Only new articles on scheduled runs.** Turn on `dedupe` and each run returns only articles that earlier runs haven't returned.

Each result includes the title, URL, authors, publish and update dates, category and tag names, excerpt, featured image, word count, reading time, paywall and sponsored flags, and the **full body text**.

### Why use this TechCrunch scraper?

- **Full text, ready for LLMs.** You get the body in markdown, text or cleaned HTML, with ads, newsletter prompts and related-link blocks removed.
- **Exact-phrase keyword matching.** Raw TechCrunch search returns loose matches. Results are re-checked so `"series b"` returns only articles that actually say "Series B".
- **No self-promo noise.** TechCrunch's own event ads (posts under the "TechCrunch Events" byline, about 10% of the Startups feed in October 2026) are skipped by default. Ticket call-to-action lines inside news stories are stripped too.
- **Every filter combines with the others.** You can mix keywords, categories, tags, authors, dates and URLs in a single run.
- **Precise date ranges** for backfills or tracking a company's coverage.
- **Multi-author support.** Every co-author is listed, and `author` stays flat for CSV users.
- **Tags and categories come as human-readable names**, not numeric ids.
- **New-only scheduled runs** with cross-run dedupe.
- **No browser.** The actor reads TechCrunch's public WordPress API directly, so it's fast and cheap per article.

### Input modes

You can use any combination of the fields. Leave everything empty to get the **latest TechCrunch articles**.

#### 1. Keyword search

```json
{
    "keywords": ["anthropic", "series b"],
    "dateFrom": "30 days",
    "maxItems": 50,
    "bodyFormat": "markdown"
}
```

#### 2. Category / author / tag feed

```json
{
    "categories": ["artificial-intelligence", "venture"],
    "authors": ["kyle-wiggers"],
    "dateFrom": "2026-09-01",
    "dateTo": "2026-10-25",
    "maxItems": 200
}
```

#### 3. Article URL list

```json
{
    "startUrls": [
        "https://techcrunch.com/2025/01/27/deepseek-displaces-chatgpt-as-the-app-stores-top-app/",
        "https://techcrunch.com/2024/12/20/openai-announces-new-o3-model/"
    ],
    "bodyFormat": "text"
}
```

#### Scheduled daily feed with only new articles

Create a [schedule](https://docs.apify.com/platform/schedules) (for example daily at 07:00) with this input. Each run returns only articles that earlier runs with the same `dedupeStoreName` haven't returned.

```json
{
    "categories": ["fintech"],
    "dateFrom": "3 days",
    "maxItems": 200,
    "dedupe": true,
    "dedupeStoreName": "techcrunch-fintech-daily"
}
```

Use a different `dedupeStoreName` for each feed. If you delete the store, its memory is reset.

#### How the inputs combine

| Input | Behavior |
| --- | --- |
| `keywords` | Each keyword runs as a **separate search**. Results are merged. |
| `strictKeywordMatch` | On by default. TechCrunch's own search matches the words separately, so `series b` would also return an article about "a series of apps". With this on, only articles that contain the exact phrase in the title, excerpt or body are kept. Dropped results don't count toward `maxItems`. |
| `categories`, `tags`, `authors` | **Filters**: OR within a field and AND across fields. For example, `categories: [ai, fintech]` + `authors: [x]` means "(AI or Fintech) and by x". They apply to **every keyword search**. |
| Filters without keywords | One feed query runs using the filters. |
| Nothing at all | The latest articles. |
| `startUrls` | Processed **in addition** to any search, before the search results. |
| `includeEventPromos` | Off by default, which skips TechCrunch's event marketing posts. Start URLs are never skipped. |
| `dateFrom` / `dateTo` | Inclusive. A date-only `dateTo` covers the whole day (UTC). |
| `maxItems` | Total cap across all sources, after deduplication. |

Results are **deduplicated within a run** by post id and canonical URL, so tracking parameters, `www.` and `/amp/` variants count as the same article. Each item's `matchedBy` lists every source that found it, for example `["keyword:anthropic", "url"]`. Feed results are labeled with the specific filter values they matched, for example `category:fintech` or `author:kyle-wiggers`. With several sources, results are sorted newest first.

If a category, tag or author can't be found, the run logs a warning with suggestions and continues with the values that did resolve. If **none** of the values for a field resolve, searches using that filter return **no results**. The actor never silently drops the filter and returns everything.

Categories, tags and authors accept a slug (`artificial-intelligence`), a display name (`AI`), or a TechCrunch URL (`https://techcrunch.com/author/kyle-wiggers/`).

### Sample output

```json
{
    "id": 3179660,
    "url": "https://techcrunch.com/2026/10/26/matiks-raises-10m-to-expand-its-math-and-puzzle-gaming-platform/",
    "slug": "matiks-raises-10m-to-expand-its-math-and-puzzle-gaming-platform",
    "title": "Matiks raises $10M to expand its math and puzzle gaming platform",
    "excerpt": "Matiks has introduced a new platform for users to create games using AI.",
    "author": "Ivan Mehta",
    "authorUrl": "https://techcrunch.com/author/ivan-mehta/",
    "authors": [
        {
            "name": "Ivan Mehta",
            "slug": "ivan-mehta",
            "url": "https://techcrunch.com/author/ivan-mehta/"
        }
    ],
    "publishedAt": "2026-10-26T14:08:04Z",
    "updatedAt": "2026-10-26T16:02:09Z",
    "categories": [
        "Apps",
        "Fundraising"
    ],
    "primaryCategory": "Apps",
    "tags": [
        "games",
        "General Catalyst"
    ],
    "body": "Over the past decade, head-to-head brain games like QuizUp rocketed in popularity, reaching at one point millions of users. After that, battle royale games like Fortnite and PlayerUnknown’s Battlegrounds had their moment in the spotlight. Lately, growth of [mobile games has slowed …",
    "bodyFormat": "markdown",
    "imageUrl": "https://techcrunch.com/wp-content/uploads/2026/10/Matiks-co-founders.jpg",
    "wordCount": 673,
    "readingTimeMinutes": 3,
    "isPaywalled": false,
    "isSponsored": false,
    "language": "en",
    "matchedBy": [
        "keyword:series a"
    ],
    "source": "api",
    "scrapedAt": "2026-10-27T03:40:21.926Z"
}
```

This is a real item from a run on Apify (October 2026), with `body` shortened for display.

### Output fields

| Field | Type | Description |
| --- | --- | --- |
| `id` | number or null | WordPress post id (null for items parsed from the HTML page) |
| `url` | string | Canonical article URL |
| `slug` | string | URL slug |
| `title` | string | Headline |
| `excerpt` | string or null | Dek or summary |
| `author` | string or null | Primary author's name |
| `authorUrl` | string or null | Primary author's profile page |
| `authors` | object\[] | All authors: `name`, `slug`, `url` |
| `publishedAt` | ISO 8601 or null | Publish time (UTC) |
| `updatedAt` | ISO 8601 or null | Last update (UTC) |
| `categories` | string\[] | Category names |
| `primaryCategory` | string or null | Main category |
| `tags` | string\[] | Tag names |
| `body` | string or null | Full text in `bodyFormat`; null when `includeBody` is false |
| `bodyFormat` | string or null | `markdown`, `text` or `html` |
| `imageUrl` | string or null | Featured image |
| `wordCount` | number | Words in the body |
| `readingTimeMinutes` | number | Estimated reading time |
| `isPaywalled` | boolean | True when the public body is truncated (TechCrunch+ or a gate) |
| `isSponsored` | boolean | Sponsored or partner content |
| `language` | string | Content language (`en`) |
| `matchedBy` | string\[] | Sources that found the article: `keyword:…`, `category:…`, `tag:…`, `author:…`, `url`, `latest` |
| `source` | string | `api` (WordPress API) or `html` (page-parser fallback) |
| `scrapedAt` | ISO 8601 | When the item was scraped |

You can export the dataset as JSON, CSV, Excel, XML or RSS from the Output tab or through the API. The `STATS` record in the run's key-value store has counts for that run: found, pushed, duplicates skipped, previously seen skipped, and failed URLs.

### Pricing

The actor uses **pay per event**:

| Event | Price | When it's charged |
|---|---|---|
| Actor start | $0.00005 per run | Once when a run starts. |
| Article | $0.002 per article (**$2.00 per 1,000**) | Once for each article saved to the dataset. |

A run that finds nothing costs only the $0.00005 start fee. You aren't charged separately per dataset result, only per article. Set a maximum charge per run in the run options. The actor stops cleanly when that limit is reached.

### Use with MCP and AI agents

The actor is **MCP-ready**: input names are standard, no field is required, and every field has a description and an example. To add it to Claude Desktop, Cursor or another MCP client through [Apify's MCP server](https://mcp.apify.com), select the actor `scrapelabmax/techcrunch-scraper`. An agent can then answer "what did TechCrunch say about Anthropic this week?" with a call like:

```json
{ "keywords": ["anthropic"], "dateFrom": "7 days", "maxItems": 20 }
```

For **RAG** ingestion, use `bodyFormat: "markdown"`, chunk the `body` field, and store `url`, `title`, `publishedAt`, `categories` and `tags` as metadata.

### FAQ and limits

**Does it need a proxy?** No. The TechCrunch API works without one. If you hit rate limits, enable Apify datacenter proxy in the Advanced section.

**What about paywalled articles?** The actor returns only what is publicly available. If the public body is truncated, `isPaywalled` is `true`, so the item is never passed off as a complete article.

**Can I scrape thousands of historical articles?** Yes. Use `dateFrom` and `dateTo` with a high `maxItems` (up to 100,000). Results come newest first.

**Why was one of my URLs skipped?** Only TechCrunch article URLs (`techcrunch.com/YYYY/MM/DD/slug/`) are processed. Category pages, author pages, the homepage and other sites are skipped with a warning in the log.

**How does dedupe work?** With `dedupe: true`, the actor stores a SHA-1 hash of each returned article's canonical URL in a named key-value store, and later runs skip those articles. Skipped articles don't count toward `maxItems`. Dedupe is off by default because one-off pulls are the most common use.

**Is scraping TechCrunch allowed?** The actor reads publicly available pages and API endpoints. TechCrunch's terms restrict republishing its content, so personal, research and internal-analysis use is the typical case. You are responsible for how you use the data. The actor doesn't store or republish anything outside your own Apify storage.

**Something broke or a field is missing?** Open an issue on the actor's Issues tab and include the run ID.

# Actor input Schema

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

Search terms, each run as a separate TechCrunch search (e.g. a company, product or sector).

## `strictKeywordMatch` (type: `boolean`):

Keep only results that contain each keyword as a whole phrase (TechCrunch search alone matches the words separately).

## `startUrls` (type: `array`):

TechCrunch article URLs (techcrunch.com/YYYY/MM/DD/slug/) to fetch in addition to any search; other pages are skipped with a warning.

## `categories` (type: `array`):

Category slugs, names or URLs, e.g. "artificial-intelligence", "Fintech" or https://techcrunch.com/category/venture/.

## `authors` (type: `array`):

Author slugs, names or profile URLs, e.g. "kyle-wiggers" or https://techcrunch.com/author/kyle-wiggers/.

## `tags` (type: `array`):

Tag slugs, names or URLs, e.g. "openai" or https://techcrunch.com/tag/openai/.

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

Earliest publish date: ISO date/datetime (2026-10-01) or relative ("7 days", "2 weeks", "1 month", "yesterday").

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

Latest publish date (inclusive): ISO date/datetime (2026-10-25) or relative ("1 day", "yesterday", "today").

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

Maximum number of articles to return across all sources (1 to 100,000; 0 means the default of 100).

## `includeBody` (type: `boolean`):

Include the full article body; turn off for metadata-only results (title, author, date, excerpt, URL).

## `bodyFormat` (type: `string`):

Format of the article body: markdown (best for LLMs and RAG), plain text, or cleaned HTML.

## `includeEventPromos` (type: `boolean`):

Include TechCrunch's own event marketing posts (byline "TechCrunch Events", e.g. ticket deadlines); excluded by default.

## `dedupe` (type: `boolean`):

Remember returned articles in a named key-value store and skip them in later runs; turn on for scheduled feeds.

## `dedupeStoreName` (type: `string`):

Named key-value store that remembers seen articles (default "techcrunch-scraper-seen"); use one name per scheduled feed.

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

Maximum parallel requests to TechCrunch (1 to 50); keep it low to stay polite.

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

Optional proxy. The TechCrunch API works without one; Apify datacenter proxy helps if you hit rate limits.

## Actor input object example

```json
{
  "keywords": [
    "anthropic",
    "series b"
  ],
  "strictKeywordMatch": true,
  "startUrls": [
    "https://techcrunch.com/2026/10/20/example-startup-raises-40m-series-b/"
  ],
  "categories": [
    "artificial-intelligence",
    "fintech"
  ],
  "authors": [
    "kyle-wiggers"
  ],
  "tags": [
    "openai"
  ],
  "dateFrom": "7 days",
  "dateTo": "2026-10-25",
  "maxItems": 50,
  "includeBody": true,
  "bodyFormat": "markdown",
  "includeEventPromos": false,
  "dedupe": true,
  "dedupeStoreName": "techcrunch-ai-daily",
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `articles` (type: `string`):

One item per article, with the full text in the requested format.

## `stats` (type: `string`):

Counts of found, pushed, duplicate, previously seen and failed items.

# 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 = {
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapelabmax/techcrunch-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 = {
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapelabmax/techcrunch-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 '{
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapelabmax/techcrunch-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapelabmax/techcrunch-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/DtdnOtFvdSysAnPsG/builds/QZTDh9U6GIk9MluPt/openapi.json