# Anthropic Ipo Pulse (`fabian_maume/anthropic-ipo-pulse`) Actor

Anthropic IPO Pulse is an orchestrator Actor that tracks how the internet talks about the Anthropic (Nasdaq: ANT) IPO. It collects posts from X, LinkedIn, YouTube, Threads and stock news. Each post is scored by an LLM for sentiment, relevance and how extreme the take is.

- **URL**: https://apify.com/fabian_maume/anthropic-ipo-pulse.md
- **Developed by:** [Fabian Maume](https://apify.com/fabian_maume) (community)
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 55.6% 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/actors/running/actors-in-store.md#pay-per-usage

## 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

## Anthropic IPO Pulse

Anthropic IPO Pulse is an orchestrator Actor that tracks how the internet talks about the Anthropic (Nasdaq: ANT) IPO. It collects posts from X, LinkedIn, YouTube, Threads and stock news. Each post is scored by an LLM for sentiment, relevance, how extreme the take is, and its topic. The Actor saves daily aggregates and the most over-optimistic and over-pessimistic quotes to a named key-value store, where a website can read them.

### What it does

| Step | Actor | Interface |
|---|---|---|
| X search, day by day (four 6-hour slices) or the live window | [xquik/x-tweet-scraper](https://apify.com/xquik/x-tweet-scraper) | Actor run |
| LinkedIn posts | [harvestapi/linkedin-post-search](https://apify.com/harvestapi/linkedin-post-search) | Actor run |
| YouTube videos | [streamers/youtube-scraper](https://apify.com/streamers/youtube-scraper) | Actor run |
| Threads posts (keyword search) | [lergassy/threads-scraper](https://apify.com/lergassy/threads-scraper) | Actor run |
| Stock news | [publicmoney/marketwatch-scraper](https://apify.com/publicmoney/marketwatch-scraper), [publicmoney/yahoo-finance-scraper](https://apify.com/publicmoney/yahoo-finance-scraper) (news mode) | Standby HTTP |
| Quotes | [publicmoney/yahoo-finance-scraper](https://apify.com/publicmoney/yahoo-finance-scraper), [publicmoney/nasdaq-scraper](https://apify.com/publicmoney/nasdaq-scraper) | Standby HTTP |
| Ticker news sentiment | [publicmoney/sentiment-mini](https://apify.com/publicmoney/sentiment-mini) | Standby HTTP |
| Post scoring | [apify/openrouter](https://apify.com/apify/openrouter) | Standby HTTP |

### Modes

- **backfill**: collects every day from `dateFrom` to `dateTo` and writes them to the baseline. Run it once.
- **daily**: collects yesterday. Schedule it at 00:15 UTC so LinkedIn's "newest first" results cover the day that just ended.
- **news**: sweeps MarketWatch and Yahoo Finance news only. Schedule it every 2 hours, because the feeds keep only about a day of stories.
- **rescore**: no scraping. Re-scores posts already saved in `<storeName>-posts` for the date range and rebuilds those days, storylines included. Use it when a run hit its LLM budget, or once to add topics to posts scored before topics existed (they are sent to the LLM again).
- **live**: snapshots the last `liveWindowMinutes` (default 15) for X and Threads, plus the news sweep and quotes. Schedule it every 15 minutes on IPO day. LinkedIn and YouTube stay daily-only.

### Sentiment sampling

The LLM scores up to `maxScoredPerPlatformDay` (default 300) posts per platform per UTC day: the most-engaged third, so the quote wall gets the strongest takes, plus an even spread of the rest. Volume counts every collected post; the relevant count is volume × the relevance rate of the scored sample. News is always scored in full.

### Topics and storylines

The scoring prompt also tags every relevant post with one topic:

| Topic | Covers |
|---|---|
| `valuation` | price, valuation, IPO pricing, first-day pop |
| `bubble` | AI bubble or overvaluation fears |
| `governance` | Long-Term Benefit Trust, founder control, public benefit corporation structure, board |
| `safety` | AI safety and Anthropic's mission |
| `access` | retail access, allocations, how and where to buy |
| `rivals` | comparisons with OpenAI, SpaceX, Nvidia or other listings |
| `business` | Claude products, revenue, customers, losses, compute |
| `insiders` | lockups, employee and investor selling, early backers |
| `macro` | rates, markets, Nasdaq mood |
| `other` | none of these |

After backfill, daily and rescore runs write a day's aggregates, the Actor makes one more LLM call per day. It sends up to 40 of the day's most-engaged relevant scored posts and asks for at most 3 storylines, each citing 1 to 4 of those posts. Links the LLM did not get are dropped, and so is a storyline left without a link. Days with fewer than 8 relevant scored posts are skipped. If the call fails, the day keeps its previous storylines and the run carries on.

### Output

The named key-value store (default `anthropic-ipo`) holds these records:

- `baseline`: per UTC day and per platform, the volume, relevant post count, engagement, sentiment sums, bull/bear/neutral counts, the top quotes on each side, and whether a page cap was hit. It also holds the daily quote and ticker-sentiment snapshots. Each day and platform also carries:
  - `topics`: per topic, `n` (judged relevant posts with a score) and `sentimentSum` (the sum of their scores). Divide to get the topic's average sentiment.
  - `extremeBull` and `extremeBear`: judged relevant posts with an extremeness of 0.7 or more, by stance.
  - `storylines`: per UTC day, up to 3 objects with `title` (70 characters at most), `summary` (one sentence, 180 characters at most), `stance`, `topic` and `urls` (1 to 4 source posts).
- `live` and `live-timeline`: the latest live window and its history. Timeline entries carry each platform's `topics` too.
- `costs`: the estimated Apify spend per step and per run.
- `meta`: the queries, model and Actors used.

Every scored post goes to the run's dataset and to the named dataset `<storeName>-posts`, with its `topic` (`null` when the post was not scored or is not about Anthropic).

### Cost control

Set **Max total charge (USD)** on the run. The budget is split evenly across the seven steps (X, LinkedIn, YouTube, Threads, news, markets, LLM). Each batch Actor run gets its share as `maxTotalChargeUsd`, and each Standby step stops once its estimated spend reaches its share. A daily run with default settings costs about $1, so give it a cap of about $3: the even split leaves each step about $0.43, enough for LinkedIn's roughly $0.30. A live snapshot costs about $0.25 (cap $1), so a 12-hour IPO day at 4 snapshots an hour is about $12.

Storylines add one LLM call per day, about $0.005 with the default model, so a daily run costs under a cent more. The topic field adds a few output tokens per scored post. A rescore that adds topics to posts scored before topics existed re-scores up to `maxScoredPerPlatformDay` posts per platform per day, about $0.10 per day of history. It only spends on the LLM step, which gets one eighth of the cap, so give it a cap of about 8 times the LLM spend you expect.

### Requirements

The account must be able to use `apify/openrouter` (it works on the free plan). If scoring fails, posts are still counted for volume but carry no sentiment.

### License

[MIT](LICENSE)

# Actor input Schema

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

backfill: rebuild the baseline for a date range. daily: add yesterday to the baseline (schedule once a day, just after midnight UTC). news: sweep MarketWatch and Yahoo news only (schedule every 2 hours, the feeds are rolling windows). live: D-day snapshot of the last N minutes for X, Threads, news and quotes (schedule every 15 minutes). rescore: no scraping; re-scores posts already saved in the <storeName>-posts dataset for the date range and rebuilds those days.

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

First day to collect in backfill or daily mode, YYYY-MM-DD. Defaults to 2026-11-05 for backfill and yesterday for daily.

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

Last day to collect, inclusive, YYYY-MM-DD. Defaults to yesterday.

## `xQuery` (type: `string`):

One X advanced-search query for xquik/x-tweet-scraper. The Actor adds since_time:/until_time: per time slice.

## `searchQueries` (type: `array`):

Search terms passed to the LinkedIn, YouTube and Threads Actors.

## `liveTicker` (type: `string`):

The ticker the tracker is about. Use another listed ticker (for example NVDA) to rehearse D-day.

## `peerTickers` (type: `array`):

Quoted next to the main ticker and used to find Anthropic stories on Yahoo Finance.

## `llmModel` (type: `string`):

Model id used through the Apify OpenRouter Actor to score each post.

## `maxXTweetsPerDay` (type: `integer`):

Backfill and daily mode. Each day is split into four 6-hour slices so the sample covers the whole day. About $0.15 per 1,000 tweets. When a slice hits its share, that day is flagged as a floor.

## `maxXTweetsLive` (type: `integer`):

Live mode: every tweet from the live window, up to this many.

## `maxLinkedInPostsPerQuery` (type: `integer`):

Multiplied by the number of days in the range.

## `maxYouTubeVideosPerQuery` (type: `integer`):

Multiplied by the number of days in the range (up to 4).

## `maxThreadsPostsPerQuery` (type: `integer`):

Threads keyword search (lergassy/threads-scraper), about $0.0018 per post. Multiplied by the number of days in the range (up to 4).

## `maxThreadsPostsLive` (type: `integer`):

Live mode. Threads shows logged-out visitors 20 to 60 posts per keyword, so a small number is enough.

## `maxScoredPerPlatformDay` (type: `integer`):

LLM sentiment sample per platform per UTC day: the most-engaged third plus an even spread of the rest. Volume still counts every collected post, scaled by the relevance rate of the sample.

## `liveWindowMinutes` (type: `integer`):

In live mode, how far back the snapshot looks. Keep it equal to the schedule interval (15 min) so snapshots do not overlap.

## `storeName` (type: `string`):

Name of the key-value store (and the <name>-posts dataset) the website reads.

## Actor input object example

```json
{
  "mode": "daily",
  "dateFrom": "2026-11-05",
  "xQuery": "Anthropic (IPO OR stock OR shares OR valuation OR $ANT) -filter:retweets",
  "searchQueries": [
    "Anthropic IPO",
    "Anthropic stock",
    "Anthropic valuation"
  ],
  "liveTicker": "ANT",
  "peerTickers": [
    "AMZN",
    "GOOGL",
    "NVDA",
    "MSFT",
    "QQQ"
  ],
  "llmModel": "google/gemini-2.5-flash",
  "maxXTweetsPerDay": 1000,
  "maxXTweetsLive": 500,
  "maxLinkedInPostsPerQuery": 50,
  "maxYouTubeVideosPerQuery": 25,
  "maxThreadsPostsPerQuery": 30,
  "maxThreadsPostsLive": 20,
  "maxScoredPerPlatformDay": 300,
  "liveWindowMinutes": 15,
  "storeName": "anthropic-ipo"
}
```

# Actor output Schema

## `posts` (type: `string`):

No description

## `subDatasets` (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 = {
    "dateFrom": "2026-11-05"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabian_maume/anthropic-ipo-pulse").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 = { "dateFrom": "2026-11-05" }

# Run the Actor and wait for it to finish
run = client.actor("fabian_maume/anthropic-ipo-pulse").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 '{
  "dateFrom": "2026-11-05"
}' |
apify call fabian_maume/anthropic-ipo-pulse --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fabian_maume/anthropic-ipo-pulse"
        }
    }
}
```

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/caX7pH2eHS80DVFfm/builds/P0eF80K9Y7hBHsYQn/openapi.json
