# 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, 0 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

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