What it costs to summarize 1,000 news articles with an LLM

Summarizing 1,000 news articles costs $0.31 to $0.51 on a small model (Luna or Haiku) and $6.11 to $10.21 on a large one (Sol or Sonnet), at list prices checked on 2026-11-01. That is per 1,000 raw articles, after dropping 13.6% as duplicates. We counted tokens on real articles, generated 20 real summaries to measure output length and Claude's billing, and did the arithmetic in a script. Article token counts come from OpenAI's tokenizer, not Claude's or Gemini's, and the summary sample is small.

Deduping first saves pennies on a small model. The bigger lever is what you send.

Labels used throughout: MEASURED means we ran it on a dated, real batch. CALCULATED means arithmetic from measured counts times a price read that day. ASSUMED means our choice, with a sensitivity table.

Cost per 1,000 articles on five models

Base case: 1,000 raw articles, 864 kept after dedupe, 2,901 article tokens plus 150 instruction tokens in. The mean article size is MEASURED. The 150-token instruction is ASSUMED. The real instruction in our sample was 26 tokens, so 150 leaves room for format rules and a few examples. Output length is MEASURED on 20 real summaries (next section). The dollar figures are CALCULATED.

How the model treats each family:

• GPT-6 and Gemini rows: 97 output tokens, the mean visible summary length in o200k_base tokens. We measured that on Claude Haiku 5.5 summaries. We did not generate summaries with the OpenAI or Google models, so their real lengths may differ.
• Claude rows: input tokens times 1.60 and 205.5 billed output tokens, both measured on Haiku 5.5. We applied them to Sonnet 5.5 as well, because Anthropic's pricing page puts both on the same tokenizer generation. We did not measure Sonnet's output length.

That is why Haiku and Luna differ at the same $0.10 / $0.50 price, and so do Sonnet and Sol. On this batch the Claude row costs about 1.67 times the same-priced OpenAI row.

Model	Input / output per 1M tokens	No dedupe	Deduped	Saved	Batch
GPT-6 Luna (gpt-6-luna)	$0.10 / $0.50	$0.35	$0.31	$0.05	$0.15
Claude Haiku 5.5	$0.10 / $0.50	$0.59	$0.51	$0.08	$0.26
Gemini 3.5 Flash-Lite (gemini-3.5-flash-lite)	$0.30 / $2.50	$1.16	$1.00	$0.16	$0.50
GPT-6.1 Sol (gpt-6.1-sol)	$2.00 / $10.00	$7.07	$6.11	$0.96	$3.06
Claude Sonnet 5.5	$2 / $10	$11.82	$10.21	$1.61	$5.11

Prices are standard list prices from the vendors' pages, first read on 2026-10-22 and read again on 2026-11-01: Anthropic, OpenAI and Google. No price changed between the two reads. The Batch column is half the standard price, which each page lists as a 50% batch rate. Batch runs are asynchronous, so they suit a nightly digest, not a live alert.

Notes on the table:

• Claude Haiku 5.5 charges $0.50 / $2.50 for prompts over 100,000 tokens ($0.25 / $1.25 in batch). One article is far below that. A batch of articles in one prompt is not.
• Not in the table: Gemini 3.1 Flash-Lite is still listed and cheaper than 3.5 Flash-Lite, at $0.25 / $1.50, and OpenAI has a middle tier, GPT-6.1 Terra, at $1 / $5. Plug either into the script below with the "o200k" family.
• Gemini's output price includes thinking tokens, so a reasoning-heavy setting would cost more than shown.
• Tier matters most, about 20 times from small to large. Vendors at the same price differ less, about 1.67 times for Claude over OpenAI here.

What 20 real summaries cost

MEASURED on 2026-11-01 at 17:01 UTC: 20 summaries from Claude Haiku 5.5 through OpenRouter, at its listed $0.10 / $0.50 per million tokens. Temperature 0, max_tokens 400, 20 of the 48 offshore-wind articles from the token section below (random seed 17), so a different niche from the AI-news headline batch. The instruction was "Summarize this news article in 2 to 3 sentences for a daily news digest. Plain text, no preamble." That is 26 o200k_base tokens. All 20 calls succeeded, and the total spend was $0.0109.

Per call	Mean	Median	Min	Max
Prompt tokens, o200k_base count	2,761.5	2,540.5	264	6,501
Prompt tokens, billed by the model	4,422	4,060	445	10,699
Summary text, o200k_base tokens	96.7	101	42	126
Completion tokens, billed	205.5	176.5	135	400
Summary length, words	74.2	75	37	94
Cost	$0.000545	$0.000515	$0.000154	$0.001167

What it shows:

• Summaries are short. 18 of 20 ran 61 to 94 words.
• Billed output is about twice the visible text: 205.5 against 96.7 tokens. One call hit the 400 cap, and its visible summary was 69 words, so billed output includes tokens beyond the visible text. We can't say how much of that gap is tokenizer and how much is hidden tokens.
• Billed prompt tokens are 1.60 times our o200k_base count on average (mean ratio 1.6026). Anthropic's pricing page says its newer tokenizer produces "approximately 30% more tokens for the same text". Treat 1.60 as true for this batch, not as a constant.
• The billed instruction overhead was about 39 tokens, against 26 counted by us.

Mean cost per call times 864 kept articles is $0.47 per 1,000 raw articles on these sample articles. The model's Haiku figure, $0.51, is a little higher for two reasons. The sample articles averaged 2,735.5 tokens, against 2,901 for the 48. And the model charges for a 150-token instruction, where the real one was 26.

Why Haiku costs more than Luna at the same list price

Claude Haiku 5.5 and GPT-6 Luna both list at $0.10 per million input tokens and $0.50 per million output tokens. The model still prints $0.51 for Haiku and $0.31 for Luna. The whole gap comes from token counts, not price. Per article, with 3,051 input tokens (2,901 article plus the 150-token instruction, counted with o200k_base):

	Luna	Haiku
Input tokens billed	3,051	3,051 x 1.60 = 4,882
Output tokens billed	97 (visible text)	205.5
Input cost	3,051 x $0.10 / 1M = $0.000305	4,882 x $0.10 / 1M = $0.000488
Output cost	97 x $0.50 / 1M = $0.000049	205.5 x $0.50 / 1M = $0.000103
Per article	$0.000354	$0.000591
Per 1,000 raw articles (x 864)	$0.31	$0.51

The $0.205 difference per 1,000 raw articles splits in two:

• Input: 1,831 extra tokens (4,882 - 3,051) x $0.10 / 1M x 864 = $0.158. That is about 77% of the gap.
• Output: 108.5 extra tokens (205.5 - 97) x $0.50 / 1M x 864 = $0.047. That is about 23%.

Both inputs to this math are measured on one batch of 20 articles. Luna's own tokenizer and output length were not measured: its rows use the o200k_base count and Haiku's 97-token visible length. If Luna also bills more than it shows, the gap narrows. The bottom of this post lists that as unmeasured.

What we ran

We built a batch of headlines on 2026-10-22 from 14 Google News search RSS queries on one AI-news niche, each with when:1d, US English, one request every 4 seconds and no retries. The URL formats are in the Google News RSS feed guide.

for q in QUERIES:
    url = "https://news.google.com/rss/search?" + urllib.parse.urlencode(
        {"q": f"{q} when:1d", "hl": "en-US", "gl": "US", "ceid": "US:en"})
    r = requests.get(url, headers={"User-Agent": "..."}, timeout=30)
    # parse <item>: guid, title, source, pubDate
    time.sleep(4)

MEASURED: 1,039 items, 982 distinct ids, 537 distinct source strings. Seven of the 14 queries hit Google's 100-item cap.

We rebuilt the per-query counts in that image from the saved items file, because we did not keep the original console output.

The batch holds headlines only. Resolving 1,039 redirect links and scraping them would mean hundreds of requests to Google and publishers for a cost estimate, so article sizes come from somewhere else.

How many tokens a news article is

We took 48 Markdown articles already stored in our own demo org (offshore wind, 45 distinct articles, three in two feeds) and counted them with o200k_base. It was a read-only pull, with no new scrapes.

import tiktoken
enc = tiktoken.get_encoding("o200k_base")
for it in feed["items"]:
    tokens = len(enc.encode(it["content_text"] or "", disallowed_special=()))

MEASURED: mean 2,901 tokens, median 2,136, 90th percentile 6,475, maximum 15,157. The tail is heavy, so the mean sits above the median. Five items were under 600 characters (bot walls and empty pages). We kept them, because a real feed has them too. With 48 articles, treat the mean as an order of magnitude. Our earlier post on feeding news to an LLM measured Markdown at 486 to 2,223 tokens on three articles, and at 96 to 2,268 on eight copies of one story. Both fit the median.

What you send matters more than what you measure. That post also counted three pages as raw HTML. The median was 95,088 tokens, which would cost $8.27 on Luna and $165.41 on Sol per 1,000 articles ($13.25 on Haiku, $265.09 on Sonnet). That post itself calls raw HTML a strawman, and we extrapolate from three pages only. A fairer baseline is its stripped HTML text, median 2,562 tokens, about 1.2 times our 2,136. It prices at $0.28 on Luna and $5.52 on Sol. Send Markdown.

How much dedupe saves

We replayed our real stage-1 dedupe over the 1,039 items: headline normalization and clustering from the Feedmarkdown server, with Jaccard 0.6, containment 0.85 and simhash distance 3, oldest first. The method is in Why matching headlines isn't enough.

MEASURED: 141 of 1,039 items (13.6%) were dropped before any scrape. 57 were repeated ids (5.5%) and 84 were headline matches (8.1%). The cost table does not use the 898 left. It uses a clean basis of 1,000 raw articles at 13.6%, so 864 reach the model.

Take the story of the day, Anthropic's "Claude Duet" launch. 39 items matched the name: 6 repeated ids and 33 distinct. Stage 1 kept 15 as separate stories and dropped 18.

Fifteen survivors from one launch is what headline matching gives you. It only catches near-identical wording, so the rest reaches the scraper and your model. Our stage 2 compares scraped text and would drop more.

What does 13.6% save? CALCULATED, per 1,000 raw articles: $0.05 on Luna, $0.08 on Haiku, $0.16 on Gemini 3.5 Flash-Lite, $0.96 on Sol and $1.61 on Sonnet. Pennies on a small model. The saving is linear in the duplicate rate:

Dropped before the model	GPT-6 Luna	Claude Haiku 5.5	Gemini 3.5 Flash-Lite	GPT-6.1 Sol	Claude Sonnet 5.5
0%	$0.35	$0.59	$1.16	$7.07	$11.82
13.6%	$0.31	$0.51	$1.00	$6.11	$10.21
28%	$0.25	$0.43	$0.83	$5.09	$8.51
50%	$0.18	$0.30	$0.58	$3.54	$5.91

The 28% row comes from our newsletter build, where 17 of 60 items were exact repeats from overlapping queries under a 15-item cap. It is a different setup, not a second sample of the same rate, so we do not average the two or call either typical.

Dedupe pays off elsewhere: 141 fewer scrapes (not priced here) and fewer near-identical summaries to read. The risk runs the other way: templated headlines can merge two different stories, as the dedupe post shows.

What changes the number most

All CALCULATED on the base case, except where a value is marked MEASURED:

1. Model tier: about 20 times between small and large. Our call: a small model for digest blurbs, where a short plain summary is enough. Pay for a large one only when judgement matters, like ranking stories or weighing conflicting reports.
2. What you send: Markdown at $0.31 on Luna and $6.11 on Sol, stripped text at $0.28 and $5.52, raw HTML at $8.27 and $165.41.
3. Article length: the median article (2,136 tokens) costs $4.79 on Sol and $8.10 on Sonnet. The p90 article (6,475) costs $12.29 on Sol and $20.09 on Sonnet.
4. Output length. Billed output was MEASURED at a mean of 205.5 tokens on Haiku, with 135 as the minimum and 400 as the cap that one call hit. The table below runs 60, 97 (visible length), 205.5 and 400 billed output tokens. For Claude rows, 205.5 is the base case.
5. Instructions (ASSUMED 150 tokens): 26, 150, 500 and 1,000 tokens give $5.90, $6.11, $6.72 and $7.58 on Sol, and $9.87, $10.21, $11.18 and $12.56 on Sonnet. At the real 26 tokens, Luna and Haiku each drop about two cents.
6. Batch: half price, if you can wait.
7. Tokenizer. For Claude we use the MEASURED 1.60 (billed prompt tokens over o200k_base tokens, 20 prompts, one niche, one model). Anthropic says about 30%. With the Claude input scale set back to 1.00 and output unchanged, Haiku would cost $0.35 and Sonnet $7.05. With 1.30 they cost $0.43 and $8.63.

Per 1,000 raw articles at 13.6% dropped, with billed output tokens:

Model	60 out	97 out	205.5 out	400 out
GPT-6 Luna	$0.29	$0.31	$0.35	$0.44
Claude Haiku 5.5	$0.45	$0.46	$0.51	$0.59
Gemini 3.5 Flash-Lite	$0.92	$1.00	$1.23	$1.65
GPT-6.1 Sol	$5.79	$6.11	$7.05	$8.73
Claude Sonnet 5.5	$8.95	$9.27	$10.21	$11.89

Prompt caching would trim the repeated instructions. Both vendors list cache-read prices, and we did not model them.

Why this is not the $0.09 a month in our other post

Our newsletter cost post put the LLM line at about $0.09 a month. That came from one real run: 15 calls to gpt-4o-mini through OpenRouter, 11,653 prompt tokens and 1,874 completion tokens, $0.00287 as reported by OpenRouter. It capped each article at 3,000 characters, so a call averaged 777 input tokens. Run that shape through our script and a small model costs $0.11 (Luna) to $0.20 (Haiku) per 1,000 raw articles. Here the article is full length, about four times the input (3,051 tokens against 777). The figures are the same order of magnitude once the input size matches. Haiku sits higher than Luna because of the measured Claude input scale and billed output.

Recompute it for your volume

Edit PRICES if a price has moved, and pass your article count and duplicate rate.

PRICES = {  # USD per 1M tokens (input, output, tokenizer family), read 2026-10-22, re-checked 2026-11-01
    "Claude Haiku 5.5": (0.10, 0.50, "claude"),
    "Claude Sonnet 5.5": (2.00, 10.00, "claude"),
    "GPT-6 Luna": (0.10, 0.50, "o200k"),
    "GPT-6.1 Sol": (2.00, 10.00, "o200k"),
    "Gemini 3.5 Flash-Lite": (0.30, 2.50, "o200k"),
}
ART_TOK, PROMPT_TOK, OUT_TOK = 2901, 150, 97    # o200k tokens; PROMPT_TOK is ASSUMED
CLAUDE_IN_SCALE, CLAUDE_OUT_TOK = 1.60, 205.5   # measured on 20 Haiku 5.5 calls

def per_article(price, art=ART_TOK, prompt=PROMPT_TOK, out=None, scale=None):
    claude = price[2] == "claude"
    s = scale if scale is not None else (CLAUDE_IN_SCALE if claude else 1.0)
    o = out if out is not None else (CLAUDE_OUT_TOK if claude else OUT_TOK)
    return ((art + prompt) * s * price[0] + o * price[1]) / 1e6

def cost(n_raw, dup, price, **kw):
    return n_raw * (1 - dup) * per_article(price, **kw)

print(cost(5000, 0.20, PRICES["Claude Sonnet 5.5"]))  # 5,000 raw, 20% dropped

Check two lines by hand, per 1,000 raw articles at 13.6% dropped (864 kept). GPT-6 Luna: 864 x (3,051 x $0.10 + 97 x $0.50) / 1,000,000 = 864 x $0.0003536 = $0.3055, printed as $0.31. Claude Haiku 5.5, with input scaled by 1.60: 864 x (3,051 x 1.60 x $0.10 + 205.5 x $0.50) / 1,000,000 = 864 x $0.0005909 = $0.5105, printed as $0.51.

What we did not measure

• We did not judge summary quality. A model that costs 20 times less may write worse summaries. The 20 Haiku summaries were measured for length and cost, not rated.
• The output and tokenizer figures come from one model (Haiku 5.5), 20 articles and one niche (offshore wind), with one instruction. The 97-token output on the GPT-6 and Gemini rows is Haiku's visible length, not theirs.
• No Gemini tokenizer counts, and no check that the GPT-6 tokenizer matches o200k_base. The inputs come from two niches (AI-news headlines, offshore-wind articles), and the 28% row is a third setup.
• Dedupe is stage 1 only, so 13.6% is a stage-1 figure. There is no stage-2 run and no false-merge rate. The replay uses repeated ids in place of resolved URLs, and we did not save HTTP status codes.
• The window is rolling, so a rerun gives different counts. Prices change too. Treat each price as true only on the dates we read it (2026-10-22 and 2026-11-01).

Skip the plumbing

If you want articles to feed a model, Feedmarkdown pulls Google News and Google Alerts sources, drops duplicates on feed data before any scrape, and scrapes what is left into full-text Markdown. It then compares content to catch reprints. You get the result as a signed webhook, or pull it as JSON Feed 1.1 or Atom. Feedmarkdown does not summarize, so the LLM bill is separate and yours.

Take a small team on the Starter plan: $19 a month and 3,000 articles per month, where an article is one new, de-duplicated story delivered with full text. Say a feed uses all 3,000. At our 13.6% rate, that is about 3,470 raw items in, and the roughly 470 duplicates are dropped before they are scraped, sent to your model or counted against the allowance. The 3,000 that arrive are already de-duplicated, so each costs the full per-article price from the "No dedupe" column. On a small model that is 3 x $0.3536 = $1.06 a month on Luna and 3 x $0.5909 = $1.77 on Haiku. On a large one it is 3 x $7.072 = $21.22 on Sol and 3 x $11.818 = $35.45 on Sonnet. Your real volume and article length will differ.

Monthly line	GPT-6 Luna	Claude Haiku 5.5	GPT-6.1 Sol	Claude Sonnet 5.5
Starter plan	$19.00	$19.00	$19.00	$19.00
LLM, 3,000 articles	$1.06	$1.77	$21.22	$35.45
Total	$20.06	$20.77	$40.22	$54.45

The LLM lines are scaled linearly from the unrounded per-article figures, with the ASSUMED 150-token instruction and the measured output sizes above. On a small model the summaries are a rounding error next to the plan. What dedupe buys you there is a digest without repeats, not a smaller LLM bill. The plans are on the home page, or you can start a feed.