# Anthropic Blog Tracker (`ianymu/anthropic-blog-tracker`) Actor

Track every new post on anthropic.com/news. Classifies each post (model release / safety / research / business / customer story), extracts authors, tags, excerpt, and emits structured JSON. Useful for AI watchers, journalists, and competitive intel teams.

- **URL**: https://apify.com/ianymu/anthropic-blog-tracker.md
- **Developed by:** [Yanlong Mu](https://apify.com/ianymu) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

### What does Anthropic Blog Tracker do?

**Anthropic Blog Tracker** turns the official [Anthropic news page](https://www.anthropic.com/news) into a clean, queryable feed. Every post is fetched, **classified by topic** (model release / safety / research / business / customer story / policy / announcement), enriched with authors, tags, an excerpt, and emitted as a structured JSON row. Use it once or [schedule it on the Apify platform](https://docs.apify.com/platform/schedules) to get a daily diff of what Anthropic just announced — with API access, monitoring, retries, and proxy rotation included.

Built by [Ian Mu](https://github.com/ianymu) as part of a 100-Apify-Actor portfolio. Companion repo: [github.com/ianymu/claude-verify-before-stop](https://github.com/ianymu/claude-verify-before-stop) — a Claude Code hook that enforces "verify before stop" on agent runs.

### Why use Anthropic Blog Tracker?

- **AI watchers / journalists**: get a structured feed of Anthropic's announcements instead of refreshing the news page.
- **Competitive intel teams**: filter to `model-release` or `business` and pipe into a Slack channel or BI tool.
- **Founders / PMs**: track when new Claude models or capabilities ship — Opus, Sonnet, Haiku, tool use, context window changes — and react fast.
- **Researchers**: filter to `safety` and `research` for a clean reading list.
- **Aggregators / newsletter writers**: drop the JSON into your own template, no manual copy-paste.

Compared to RSS, this Actor adds **topic classification**, **author/tag enrichment**, and **filterable date ranges**, all without you owning a server.

### How to use Anthropic Blog Tracker

1. Click **Try for free** to open the Actor.
2. Optionally narrow the run with **Since date** (default: last 90 days) and **Filter by categories**.
3. Set **Max results** if you only want the top N.
4. Click **Start**. The run finishes in well under a minute for default settings.
5. Open the **Dataset** tab and export as JSON, CSV, Excel, or HTML — or fetch via the [Apify Dataset API](https://docs.apify.com/api/v2#/reference/datasets).
6. To run on a schedule, click **Actions → Schedule** and pick a cadence.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `sinceDate` | ISO date string | 90 days ago | Lower bound on `publishedAt`. |
| `categoryFilter` | array of strings | `[]` (all) | One or more of `model-release`, `safety`, `research`, `business`, `customer-story`, `policy`, `announcement`, `other`. |
| `maxResults` | integer | `50` | Hard cap on emitted rows. |
| `fetchBody` | boolean | `true` | If false, skip the detail-page fetch (faster, fewer fields). |

Example input:

```json
{
  "sinceDate": "2026-01-01",
  "categoryFilter": ["model-release", "safety"],
  "maxResults": 20,
  "fetchBody": true
}
````

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
  "title": "Claude 4 Opus 1M Context",
  "url": "https://www.anthropic.com/news/claude-4-opus-1m-context",
  "publishedAt": "2026-05-15",
  "category": "model-release",
  "authors": ["Anthropic"],
  "tags": ["claude-4", "opus", "context-window"],
  "excerpt": "Today we're introducing Claude 4 Opus with a 1M-token context window...",
  "bodySize": 4231
}
```

### Data table

| Field | Type | Notes |
|---|---|---|
| `title` | string | Post title (`og:title` preferred). |
| `url` | string | Canonical anthropic.com URL. |
| `publishedAt` | string (YYYY-MM-DD) | From `article:published_time` or `<time>` element. |
| `category` | string | One of 8 categories (see input). |
| `authors` | array of strings | From `meta[name=author]` / `article:author`. |
| `tags` | array of strings | Meta keywords + topic links + auto-tags. |
| `excerpt` | string | First ~300 chars of body. |
| `bodySize` | integer | Total length of extracted body text. |

### Pricing / Cost estimation

This Actor runs on **plain HTTP + Cheerio** — no headless browser, no proxy needed. A typical run touches one index page + up to `maxResults` detail pages at **1 req/sec** (respectful pacing). Most runs finish in **0.01–0.03 compute units**, well within the free Apify tier. Scheduling daily for a year typically stays under $1 of platform cost.

### Tips or Advanced options

- Set `fetchBody: false` if you only need title + URL + date + category — the actor skips the detail fetch and runs in seconds.
- Combine `categoryFilter` with `sinceDate` to feed exactly the right rows into a downstream Zapier / Make / n8n workflow.
- Run hourly with `sinceDate` set to 1 day ago for a low-latency announcement watcher.
- The classifier is heuristic — if it mislabels a post, open an issue and we'll tune the rules.

### FAQ, disclaimers, and support

- **Is this affiliated with Anthropic?** No. This Actor scrapes the public news page and is provided as-is.
- **Is this legal?** Scraping public, non-personal blog data is generally legal; respect [Anthropic's terms](https://www.anthropic.com/legal) and Robots.txt. The actor uses a clearly-identifying User-Agent and 1 req/sec pacing.
- **Why is a post missing?** Anthropic occasionally moves or unlists posts; the index page is the source of truth, so anything not linked there won't be picked up.
- **Bug or feature request?** Open an issue on the GitHub repo, or contact Ian Mu via [github.com/ianymu](https://github.com/ianymu). Custom variations (e.g. push directly to Postgres, classify with an LLM, alert on keyword) are available.
- **Related**: see [claude-code-changelog-watcher](https://apify.com/ianymu/claude-code-changelog-watcher) — same idea but for the `anthropics/claude-code` repo.

# Actor input Schema

## `sinceDate` (type: `string`):

Only include posts published on or after this date. Defaults to 90 days ago.

## `categoryFilter` (type: `array`):

If provided, only emit posts whose category matches one of these. Allowed values: model-release, safety, research, business, customer-story, policy, announcement, other. Empty = all.

## `maxResults` (type: `integer`):

Maximum number of posts to emit (after filtering).

## `fetchBody` (type: `boolean`):

If true, fetch each post detail page for authors / tags / excerpt. Slower but richer output.

## Actor input object example

```json
{
  "categoryFilter": [],
  "maxResults": 50,
  "fetchBody": true
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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("ianymu/anthropic-blog-tracker").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("ianymu/anthropic-blog-tracker").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 ianymu/anthropic-blog-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ianymu/anthropic-blog-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Anthropic Blog Tracker",
        "description": "Track every new post on anthropic.com/news. Classifies each post (model release / safety / research / business / customer story), extracts authors, tags, excerpt, and emits structured JSON. Useful for AI watchers, journalists, and competitive intel teams.",
        "version": "0.0",
        "x-build-id": "r6qyBdFf0Eeh8orft"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ianymu~anthropic-blog-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ianymu-anthropic-blog-tracker",
                "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/ianymu~anthropic-blog-tracker/runs": {
            "post": {
                "operationId": "runs-sync-ianymu-anthropic-blog-tracker",
                "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/ianymu~anthropic-blog-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-ianymu-anthropic-blog-tracker",
                "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": {
                    "sinceDate": {
                        "title": "Since date (ISO 8601)",
                        "type": "string",
                        "description": "Only include posts published on or after this date. Defaults to 90 days ago."
                    },
                    "categoryFilter": {
                        "title": "Filter by categories",
                        "type": "array",
                        "description": "If provided, only emit posts whose category matches one of these. Allowed values: model-release, safety, research, business, customer-story, policy, announcement, other. Empty = all.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of posts to emit (after filtering).",
                        "default": 50
                    },
                    "fetchBody": {
                        "title": "Fetch full post body",
                        "type": "boolean",
                        "description": "If true, fetch each post detail page for authors / tags / excerpt. Slower but richer output.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```