What a 50,000-Word AI Novel Draft Costs on the OpenAI and Claude APIs: $0.04 to $17

A 46-line Python script prices a full first draft on seven current models. The model you pick matters. How you feed it your own manuscript matters almost as much.

A 50,000-word first draft written by gpt-6-luna costs about 4 cents in API fees. The same draft from claude-fable-5-1 can cost $16.71.

That is a spread of more than 400x. Three things drive it: the model’s list price, the tokenizer, and whether you keep re-sending the chapters you already have.

None of these numbers is big. But the ratios tell you where the money goes, and they change the way you should write your drafting script. So I wrote a small cost model in Python. Every price in it comes from the vendors’ own pricing pages, linked below, as of October 12, 2026.

Words are not tokens

APIs bill per million tokens (MTok), not per word. So you need a conversion rate first.

• OpenAI: “100 tokens are approximately 75 words” in English, according to its token help article. That is about 1.33 tokens per word.
• Anthropic: “1M tokens is roughly 555k words” on the tokenizer used since Claude Opus 4.7, according to the models overview. That is about 1.80 tokens per word. The pricing page says this tokenizer “produces approximately 30% more tokens for the same text” than older Claude models.

Both are rough vendor estimates, not exact counts. They still matter. gpt-6.1-sol and claude-sonnet-5-5 have the same list price, $2 input and $10 output per MTok. But at these ratios, the same 50,000 words come out as about 66,700 OpenAI tokens and about 90,100 Claude tokens. Same price per token, roughly 35% more tokens per word.

The prices

Standard tier, per million tokens. OpenAI prices are from the API pricing page, Claude prices from the Claude pricing page.

The Claude cache-write column is the 5-minute cache. A 1-hour cache write costs 2x base input instead of 1.25x.

The draft I am pricing

My assumptions, not anyone’s statistics:

• 50,000 words in 25 chapters of 2,000 words.
• A 3,000-word “story bible” (outline, characters, style notes) sent with every call.
• A 100-word instruction per chapter (“Write chapter 7: …”).
• One API call per chapter.

Then three ways to give the model context:

1. Outline only. Every call sees the bible, but none of the earlier chapters.
2. Naive. Every call resends the bible plus every chapter written so far.
3. Cached. Same context as naive, but the repeated prefix is read from the prompt cache.

Option 2 is what most first scripts do. You keep appending chapters to a messages list and send the whole thing each time.

The calculator

# novel_cost.py - what a 50,000-word first draft costs on the OpenAI and Claude APIs
# Standard list prices in USD per 1M tokens, checked October 12, 2026.
OPENAI_TPW = 4 / 3        # OpenAI: "100 tokens are approximately 75 words"
CLAUDE_TPW = 1 / 0.555    # Anthropic: 1M tokens is roughly 555k words

MODELS = {  # input, cache write, cache read, output, tokens/word, long-prompt tier
    "gpt-6-luna":        (0.10, 0.125, 0.01, 0.50, OPENAI_TPW, (272_000, 2, 1.5)),
    "gpt-6.1-sol":       (2.00, 2.50, 0.10, 10.00, OPENAI_TPW, (272_000, 2, 1.5)),
    "gpt-6-astra":       (10.00, 12.50, 1.00, 50.00, OPENAI_TPW, (272_000, 2, 1.5)),
    "claude-haiku-5-5":  (0.10, 0.125, 0.01, 0.50, CLAUDE_TPW, (100_000, 5, 5)),
    "claude-sonnet-5-5": (2.00, 2.50, 0.10, 10.00, CLAUDE_TPW, None),
    "claude-opus-5-5":   (4.00, 5.00, 0.20, 20.00, CLAUDE_TPW, None),
    "claude-fable-5-1":  (10.00, 12.50, 0.25, 50.00, CLAUDE_TPW, None),
}


def draft_cost(model, words=50_000, chapters=25, bible=3_000, ask=100,
               mode="naive", think=0.0):
    """mode 'outline': each call sees only the story bible.
       mode 'naive':   each call resends the bible plus every earlier chapter.
       mode 'cached':  same context as naive, reused through prompt caching.
       think: hidden reasoning tokens per visible token (billed as output)."""
    p_in, p_write, p_read, p_out, tpw, tier = MODELS[model]
    ch, b, a = words / chapters * tpw, bible * tpw, ask * tpw
    total = 0.0
    for k in range(chapters):                      # k chapters already written
        prior = 0 if mode == "outline" else ch * k
        m_in = m_out = 1
        if tier and b + prior + a > tier[0]:       # long prompts cost more
            m_in, m_out = tier[1], tier[2]
        if mode == "cached":
            reused = b + ch * (k - 1) if k else 0  # prefix cached by last call
            new = ch if k else b                   # newest block gets written
            cost_in = reused * p_read + new * p_write + a * p_in
        else:
            cost_in = (b + prior + a) * p_in
        total += (cost_in * m_in + ch * (1 + think) * p_out * m_out) / 1e6
    return round(total, 2)


if __name__ == "__main__":
    print(f"{'model':<18}{'outline':>8}{'naive':>8}{'cached':>8}{'+think':>8}")
    for m in MODELS:
        cols = [draft_cost(m, mode=x) for x in ("outline", "naive", "cached")]
        cols.append(draft_cost(m, mode="cached", think=1.0))
        print(f"{m:<18}" + "".join(f"{c:>8.2f}" for c in cols))

Run it with python novel_cost.py:

model              outline   naive  cached  +think
gpt-6-luna            0.04    0.12    0.05    0.08
gpt-6.1-sol           0.87    2.47    0.93    1.59
gpt-6-astra           4.37   12.37    5.05    8.38
claude-haiku-5-5      0.06    0.17    0.07    0.11
claude-sonnet-5-5     1.18    3.34    1.25    2.15
claude-opus-5-5       2.36    6.68    2.50    4.31
claude-fable-5-1      5.90   16.71    5.98   10.48

Four findings stand out.

Finding 1: input costs more than the novel itself

The visible text of the draft is fixed. On claude-sonnet-5-5, 90,100 output tokens at $10 per MTok cost $0.90. On gpt-6.1-sol, 66,700 tokens cost $0.67.

But the naive run costs $3.34 and $2.47. So roughly 73% of the bill is input: the same early chapters, sent again and again.

That is the arithmetic of a growing context. Chapter 25 resends 24 chapters. Add up all 25 calls and you send 600,000 words of earlier chapters as input, twelve times the length of the book.

Finding 2: caching takes away most of that

Both vendors cache the repeated start of a prompt (the prefix).

• On OpenAI, for GPT-5.6 and later, the prompt caching guide says cache writes cost 1.25x the uncached input rate, and reads cost 0.1x, or 0.05x on GPT-6.1 Sol. The prefix must be at least 1,024 tokens, and it stays reusable for at least 30 minutes after its latest write or reuse.
• On Claude, a 5-minute cache write costs 1.25x base input. A read costs 0.1x, or 0.05x on Opus 5.5 and Sonnet 5.5, and 0.025x on Fable 5.1 (pricing page).

Feed the same context through the cache and claude-fable-5-1 drops from $16.71 to $5.98. gpt-6.1-sol drops from $2.47 to $0.93. With the cache, giving the model every earlier chapter costs only 1% to 16% more than giving it none.

The script assumes each call arrives while the previous prefix is still cached. If your pipeline pauses between chapters for human review, Claude’s 5-minute cache will expire. Use the 1-hour write or expect full input prices.

Finding 3: hidden thinking is billed like prose

Reasoning tokens never appear in your manuscript, but you pay for them. OpenAI’s reasoning guide says they “are billed as output tokens.” Anthropic’s adaptive thinking docs say the same about Claude’s thinking. On Claude Opus 5.5 and Fable 5.1, thinking is “Adaptive (always on)”, per the models overview.

How much a model thinks per chapter depends on the prompt and effort setting, so I do not have a number for you. The +think column is a what-if: one hidden token for every visible one. That alone adds about 75% to the cached Fable bill, from $5.98 to $10.48. Measure your own ratio from the usage field of each response (reasoning_tokens on OpenAI) and pass it as think.

Finding 4: price tiers kick in on long prompts

Two thresholds are worth knowing before you scale up:

• Claude Haiku 5.5 charges 5x more ($0.50 input, $2.50 output) on any request whose prompt is over 100,000 tokens, counting cache reads and writes (pricing page). At 1.8 tokens per word, that is about 55,500 words of context.
• OpenAI models over 272K input tokens pay 2x input and cache rates and 1.5x output for the whole request, per the GPT-6.1 Sol model page. That is about 204,000 words, so a single novel rarely gets there.

Watch what happens to Haiku when the book doubles:

draft_cost("claude-haiku-5-5")                                  # 0.17
draft_cost("claude-haiku-5-5", words=100_000, chapters=50)      # 2.04
draft_cost("claude-haiku-5-5", words=100_000, chapters=50,
           mode="cached")                                       # 0.5

Twice the words, 12 times the naive bill, because the last calls cross the 100,000-token line. With caching it is $0.50.

Price per draft vs. price per copy

Put the worst case next to a book’s income. On KDP’s 70% option, a $4.99 ebook with a 1 MB file pays 0.70 × ($4.99 − $0.15 delivery) = $3.39 per sale (eBook Royalties, delivery costs). I built a full KDP royalty calculator in Python for that math a few days ago.

So even the naive Fable run, $16.71, is paid back by five ebook sales. The token bill is not the expensive part of an AI-drafted book. Your hours of revision are, and so is a draft that readers drop after chapter three.

That changes what you should optimize. Spend the money on the better model and on revision passes. Do not spend it on resending the same chapters.

Three changes for your drafting script

1. Put stable content first. Story bible, then earlier chapters in order, then the new instruction last. Caching only works on an identical prefix.
2. Check that caching is actually on. On Claude, add cache_control to the request. Automatic caching then moves the breakpoint forward as the conversation grows, per the prompt caching docs. On OpenAI GPT-5.6 and later, implicit mode places a breakpoint at the end of the latest eligible message. In explicit mode, a request without any breakpoint “does not use prompt caching or create cache writes”, per the OpenAI caching guide. Either way, confirm cached tokens show up in usage.
3. Batch the non-urgent passes. Both vendors cut prices by 50% in their Batch APIs. That suits line edits or chapter summaries you don’t need right away.

If you would rather not build the pipeline at all, ImagineYourBook is a managed tool for the same job. It plans a book from a brief, writes it chapter by chapter with a story bible for continuity, and exports Word and EPUB files. It sits next to the raw APIs here, not instead of revision: treat the output as a draft to edit.

Whichever route you take, one KDP rule applies. Amazon’s content guidelines require you to disclose AI-generated text, images or translations when you publish. That holds “even if you applied substantial edits afterwards.” Using AI only to edit or error-check your own writing counts as AI-assisted and does not need to be disclosed.

Try it

1. Save the script as novel_cost.py.
2. Change words, chapters and bible to match your book.
3. After one real chapter, read the token counts from the API response and replace my estimates.
4. If naive is more than twice outline, fix your caching before you write chapter two.

The novel itself costs cents to a few dollars. Re-sending it to the model is what makes the bill grow, and one cache_control line fixes most of that.