Tag: Anthropic

• 

  Claude API Pricing & Token Rates Schedule (2026)

  Claude’s API pricing is token-based: you pay for the tokens you send (input) and the tokens Claude generates (output). Rate limits, service tiers, prompt caching, batch processing, and feature-specific charges all affect your actual bill. Last refreshed: October 8, 2026 (Pacific) against platform.claude.com pricing and Haiku 5.5. Seat prices did not move. The list-price change is Haiku 5.5 and a Sonnet 5.5 cache-read cut.

  Direct Answer (October 8, 2026): Official first-party list: Haiku 5.5 $0.10 / $0.50 per MTok for prompts up to 100,000 tokens, and $0.50 / $2.50 over 100,000 tokens (Haiku 4.5 remains $1 / $5); Sonnet 5.5 $2 / $10 with cache reads now $0.10 (was $0.20); Sonnet 5 $2 / $10 with cache reads still $0.20; Sonnet 4.6 and Sonnet 4.5 $3 / $15; Opus 5.5 $4 / $20 with cache reads at $0.20; Opus 5 / Opus 4.8 $5 / $25; Fable 5 and Mythos 5 $10 / $50 with cache reads at $1; Fable 5.1 and Mythos 5.1 $10 / $50 with cache reads at $0.25. Batch API is 50% off. Do not average Haiku 5.5’s two prompt-length bands.

  Per-Token Pricing by Model

  

  All prices are per million tokens (MTok), verified October 8, 2026. Claude Haiku 5.5, launched October 7, lists $0.10 input / $0.50 output up to 100,000 prompt tokens and $0.50 / $2.50 above that. Haiku 4.5 remains $1 / $5. Claude Sonnet 5.5 remains $2 input / $10 output. Cache reads on Sonnet 5.5 are now $0.10, down from $0.20. Claude Opus 5.5 remains $4 / $20 with cache reads at $0.20. Fast mode for Opus 5.5 is $8 / $40. Sonnet 4.6 remains $3 / $15. Fable 5.1 keeps $10 / $50 with cache reads at $0.25.

  Prompt Caching Pricing

  5-minute cache write is 1.25x input. 1-hour cache write is 2x input. Cache read is 0.05x on Sonnet 5.5 and Opus 5.5, 0.1x on Sonnet 5 and Haiku 4.5. Fable 5.1 and Mythos 5.1 use 0.025x ($0.25/MTok). Haiku 5.5 cache reads are $0.01 / $0.05 (under / over 100k). Haiku 5.5 cache writes are $0.125 / $0.625. Opus 5.5 cache writes $5 / 1-hour $8 / reads $0.20. Opus 5 cache writes $6.25 / reads $0.50. Sonnet 5.5 cache writes $2.50 / reads $0.10. Sonnet 5 cache writes $2.50 / reads $0.20. Sonnet 4.6 cache writes $3.75 / reads $0.30. Haiku 4.5 cache writes $1.25 / reads $0.10.

  Batch Processing: 50% Off

  The Batch API processes requests asynchronously at half the standard rate. Haiku 5.5 batch is $0.05 / $0.25 under 100k tokens and $0.25 / $1.25 over. Sonnet 5.5 and Sonnet 5 batch list is $1 / $5. Sonnet 4.6 batch list is $1.50 / $7.50. Opus 5.5 batch is $2 / $10. Opus 5 batch is $2.50 / $12.50. Fable 5.1 batch is $5 / $25.

  How to Calculate Your Monthly Bill

  Example at Sonnet 5.5 list ($2 / $10): 2,000 input tokens and 500 output tokens × 10,000 requests/day = 20 MTok input ($40) + 5 MTok output ($50) = $90/day, about $2,700/month before cache or batch. Same volume on Opus 5.5 at $4 / $20 is $180/day before cache. Same volume on Haiku 5.5 at the under-100k band ($0.10 / $0.50) is $4.50/day before cache.

  Same volume with caching on Sonnet 5.5: at a 90% cache-hit rate, 18 of those 20 MTok re-read from cache at $0.10/MTok ($1.80) instead of $2/MTok ($36) — input drops from $40 to $5.80/day. The cache line, not the input line, is usually what separates the sticker price from the real bill. That example used $0.20 before October 7.

  Service Tiers and Rate Limits

  Priority, Standard, and Batch tiers still apply. US-only inference (inference_geo: "us") on Claude 4.6 and later is 1.1x. Fast mode on Opus 5.5 is $8 / $40. Fast mode on Opus 5 / Opus 4.8 is $10 / $50. Haiku 5.5 is the exception on long-context pricing: prompts over 100,000 tokens use the higher band. Other Claude 4.6 and later models keep one per-token rate through the 1M window. Check live limits in the Claude Console; published RPM/ITPM figures move by spend tier. Confirm five-hour windows in Settings > Usage, not from a screenshot.

  Anthropic said on October 7 it will roll out monthly Claude Platform credits this week: Max 5x $100, Max 20x $200, Team up to $500 pooled. That is an announced credit, not a seat-price change. Confirm in the Help Center article before you book it as included usage.

  Frequently Asked Questions

  How much does Claude API cost for a small project?

  A small project making 100–500 API calls per day with Haiku 5.5 on the under-100k band is cheaper than the same volume on Haiku 4.5 ($1 / $5). Sonnet 5.5 at the same volume is cheaper than Sonnet 4.6 because the list is $2 / $10, not $3 / $15.

  Is there a free tier for the Claude API?

  Anthropic does not offer a permanent free API tier. You need to add a payment method and load credits. The October 7 Max and Team credit is a subscriber allowance, not a public free tier.

  What’s the cheapest way to use the Claude API?

  Use Haiku 5.5 on prompts under 100,000 tokens ($0.10/MTok input), enable prompt caching, and batch non-real-time work (50% off). Haiku 4.5 remains $1 / $5 if a workload is pinned to that SKU. For mid-tier quality, prefer Sonnet 5.5 at $2 / $10 over Sonnet 4.6 at $3 / $15 unless you need the 4.6 SKU specifically. For Opus-class work, prefer Opus 5.5 at $4 / $20 over Opus 5 at $5 / $25 unless you are pinned to the older SKU.

  How do Claude API costs compare to OpenAI?

  This page’s prior OpenAI pair was gpt-6.1-sol at $2 / $10 short-context and GPT-5 at $1.25 / $10. Those OpenAI rows were not re-verified on this pass. Sonnet 5.5 at $2 / $10 is unchanged. Haiku 5.5 at $0.10 / $0.50 under 100k is the new cheap Claude band. Compare the exact SKU pair, not the family name.

  What happens when I hit a Claude API rate limit?

  The API returns HTTP 429. Back off and retry with exponential backoff; if you hit limits regularly, request a higher spend tier in the Claude Console. Our Claude rate limits guide covers the RPM/TPM tiers and the full 429 playbook.

  Do cached tokens cost the same as fresh input?

  No. Cache reads run 0.025×–0.10× the input price depending on model — $0.10/MTok on Sonnet 5.5, $0.20 on Sonnet 5 and Opus 5.5, $0.25 on Fable 5.1, $0.01 on Haiku 5.5 under 100k, $0.10 on Haiku 4.5. On cache-heavy workloads the read line sets your bill, not the input line.

  Related: Claude AI pricing guide · Fable 5 pricing, cache rates & plan access · Claude rate limits & tiers · How to get an Anthropic API key · How much does Claude AI cost

  June 4, 2026

• 

  Claude in Chrome: Setup, Use Cases & Limits (2026)

  Last refreshed: October 6, 2026 — primary: Get started with Claude in Chrome (Claude Help Center). Plan matrix re-checked against claude.com/pricing.

  Direct Answer (6 October 2026): The Claude in Chrome extension lets Claude read the page you have open and work in a side panel — it reads the live DOM, clicks, fills forms, and downloads files, all inside the browser. It is not Cowork and it is not Claude Code. On the claude.com/pricing comparison read 6 October 2026, Claude in Chrome is No on Free and Yes on Pro, Max 5x, Max 20x, Team, and Enterprise. Permission claims (passwords, history, autofill) were not re-checked against the Chrome Web Store on this date.

  Claude in Chrome is a browser extension that brings Claude into the tab you already have open. Rather than copying the page into a chat, the extension lets Claude see the page and answer next to it. This guide is built from documented operational use across eight previously separate guides — setup, use cases, profiles, web-app automation, the API decision, the Cowork comparison, LinkedIn workflows, and a production video pipeline — merged into one canonical reference.

  What Claude in Chrome actually is

  Claude in Chrome is a browser extension — separate from claude.ai, separate from Cowork — that connects Claude to your active Chrome tab. Once installed and connected, Claude gains browser-native tools it doesn’t have in a standard chat session:

  • Reading page content — text, links, form fields, and interactive elements on the current tab
  • Clicking — buttons, links, checkboxes, and UI controls (with your permission per action)
  • Filling forms — with explicit approval per action
  • Scrolling and navigating between your open tabs
  • Downloading files through the browser

  The key technical distinction: Claude in Chrome works through DOM access, not screenshots. That makes it faster and more precise for web tasks than screenshot-based computer use — it reads the page structure directly rather than looking at pixels. It has no awareness of your desktop, no filesystem access, and cannot open applications outside the browser. If you close Chrome, Claude in Chrome stops.

  How to install Claude in Chrome

  1. Search the Chrome Web Store for the official Anthropic Claude extension.
  2. Click Add to Chrome, then sign in.
  3. Click the toolbar icon to open the side panel.
  4. Click Connect to link the extension to your chat session.

  Plan availability verified 6 October 2026 against claude.com/pricing: No on Free; Yes on Pro, Max 5x, Max 20x, Team, and Enterprise. Usage draws from the same seat pool as claude.ai — a rolling five-hour window, plus weekly limits on paid plans. The install steps and permission claims above were not re-checked against the Chrome Web Store on this date.

  What it can do — and what it can’t

  It can: summarize articles and long docs, extract HTML tables, draft replies against a visible thread, walk a pricing or docs page, research a LinkedIn profile (read-only), fill forms with your approval, and operate web apps that have no API.

  It cannot: see a page you aren’t authenticated to. Heavy iframe / SPA pages can fail. It does not get your history, passwords, or autofill data. It does not submit purchases without you confirming. It is not a bulk scraper — it works one page at a time, in your session. And it cannot run on a schedule or while you’re away: every session needs you present and a manual click to connect.

  Claude in Chrome vs Cowork vs Chat vs API

  Four tools, four jobs. The decision rule that holds up in practice:

  • Use Chat when the work is text in a conversation.
  • Use Chrome when the source is a live web page and you’re present.
  • Use Cowork when the work is files on the desktop or needs to run on a schedule while you’re asleep.
  • Use the API first whenever one exists for what you need — Chrome is the fallback, not the default.

  The API-first rule. An API call is deterministic — same endpoint, same payload, same result. A Chrome UI interaction depends on the current state of a live webpage, and web pages change. Chrome automation runs at human browsing speed, needs a running logged-in browser, and typically needs maintenance when sites redesign. Expect roughly 80-90% reliability per run versus 99%+ for a good API integration. So: API first; Claude in Chrome when the API doesn’t exist, doesn’t expose what you need, or the task is genuinely one-off. The cleanest architectures use both — API for everything it can reach, Chrome for the UI-only edges.

  One question resolves most cases: do you need it to run while you’re asleep? If yes, that’s Cowork territory. If no, Chrome with you present.

  Practical use cases

  Research and summarization

  Long docs, papers, vendor pages, competitive pricing pages — open the URL and ask for a comparison against your offer, or a summary with the numbers pulled out. Tables come out clean because Claude reads the DOM, not a screenshot.

  Email in the browser

  Draft against the thread you can still see. Claude reads the email context in Gmail and drafts the reply next to it.

  LinkedIn: assist, don’t automate

  The genuinely useful LinkedIn jobs are read-and-prepare: summarizing a prospect’s profile before a call, researching a company page, scanning a feed for the day’s relevant threads, drafting a DM or comment for your approval. The standout use case is paste-assist for long-form Articles — schedulers can only push short feed posts through the official API, so native Articles stay a manual copy-paste, and a guided in-browser assist turns that tedium into minutes.

  What to never do: automated feed posting, bulk connection requests, or bulk messaging. Networks detect automation, it violates terms of service, and accounts get throttled or suspended. The browser is an assistant, not a posting robot. Keep a human on the trigger for anything that publishes or sends.

  Automating web apps without an API

  The pattern that works: Claude Chat writes the work order; Claude in Chrome executes it. You describe the task to Chat; Chat writes precise step-by-step instructions (what page, what to click, what to fill, what to confirm); you paste that into the Chrome session; it executes. Documented uses include cloud console navigation, DNS updates through a registrar UI, posting through scheduling tools whose API tier lacked the endpoint, and operating browser-based AI tools that have no API at all.

  A good work order is sequential, specific about UI elements, anticipates surprises (login screens, MFA prompts, CAPTCHAs — which Chrome cannot solve), and ends with a confirmation step. Pre-login matters: Claude can only touch services you’re already logged into in that profile. And never leave it running on high-stakes actions — payments, publishing, deletions — without reviewing first. There is no undo button.

  Multiple Chrome profiles

  Each Chrome profile is its own island — separate logins, extensions, sessions. Claude in Chrome connects to one profile at a time via your manual click. The extension must be installed separately on each profile. When Claude needs a different profile mid-session it calls switch_browser; you click Connect in the right window. Practical ceiling: two to three profiles per session before the manual clicks get tedious. Keep personal tabs in a profile you never connect.

  The production pattern: scheduled pipelines

  One documented production pipeline shows how far the pattern goes: two staggered Cowork scheduled tasks use Claude in Chrome to operate a browser-based notebook tool with no API — creating notebooks from article URLs, triggering video generation, harvesting finished videos, and drafting WordPress watch pages. The architecture (trigger, wait, harvest, log) generalizes to any browser-only tool. The real failure modes, documented from production: generation timeouts (most common), Chrome tab closures killing a run, and daily per-account generation limits handled by rotating accounts across profiles. Posts go up as drafts — a human spot-check before publishing is intentional.

  Privacy

  The extension only sends page content when you invoke it. It sees visible page content you share — not passwords, history, or autofill. Team and Enterprise default to no training on that content. Review permissions at install, and use judgment with regulated or confidential data: page content is processed by Anthropic’s systems under your plan’s privacy settings.

  Frequently asked questions

  Is Claude in Chrome free?

  No. Not on the Free plan per the 6 October 2026 pricing table. Pro, Max, Team, and Enterprise are Yes.

  Does it work on Edge or Brave?

  Official support is Chrome. Chromium forks sometimes work; don’t count on it for production.

  Can it see my passwords?

  No. Visible page content you share only.

  Can Claude in Chrome run overnight or on a schedule?

  No. It needs an active session and a manual connection per session. Scheduled, unattended runs are Cowork’s job.

  Can it switch Chrome profiles by itself?

  No. Every profile switch needs your click on Connect. Deliberate design, not a limitation to work around.

  Is it safe to use while logged in to sensitive accounts?

  Use a dedicated work profile for Claude sessions and keep personal or sensitive tabs in a profile that’s never connected. Claude can see and interact with any tab open in the connected profile.

  What happens when a site redesigns and breaks my workflow?

  Claude reports it couldn’t find the expected element and stops — it won’t guess or click something random. Update the work order to match the new UI. Writing instructions in terms of intent (“find the button that saves the record”) is more resilient than describing exact pixels, but no wording survives every redesign.

  How is this different from Claude for Microsoft 365?

  Chrome is any website in the browser. Microsoft 365 is Word, Outlook, and Teams.

  Sources: Claude Help Center, Get started with Claude in Chrome; claude.com/pricing (plan availability verified 6 October 2026); documented operational use across eight Tygart Media guides (May–September 2026). Install-step and permission claims were not re-checked against the Chrome Web Store on the verification date. Desktop-behavior claims about Cowork were not re-tested against Anthropic on that date.

  June 4, 2026

• 

  How Much Does Claude AI Cost? The Plain-English Pricing Breakdown for 2026

  Last verified: October 8, 2026 (Pacific) against claude.com/pricing, platform.claude.com pricing, and Haiku 5.5.

  Direct Answer: Claude costs $0 on Free; Pro is $20/month ($17 annual); Max starts at $100/month with a choice of 5x or 20x Pro usage per five-hour session (the Help Center lists the 20x tier at $200/month on the web); Team Standard is $20–$25/seat; Team Premium is $100–$125/seat; Enterprise is $20/seat plus usage. API list rates: Haiku 5.5 $0.10/$0.50 under 100k prompt tokens ($0.50/$2.50 over), Haiku 4.5 $1/$5, Sonnet 5.5 and Sonnet 5 $2/$10, Opus 5.5 $4/$20, Opus 5 $5/$25 per million tokens. Sonnet 5.5 cache reads are $0.10.

  If you searched “how much is Claude AI” or “Claude AI cost,” here is the straight list — seat plans first, then API token rates. Numbers below are verified October 8, 2026. Seat prices did not move on October 7.

  The Free Tier: $0

  

  Claude’s free tier is $0 — no credit card required. Chat on web, mobile, and desktop, web search, memory, file creation, and code execution are included. Claude Code is not. Usage limits are tighter than paid seats.

  Claude Pro: $20/Month

  Pro costs $20/month billed monthly or $17/month if you pay annually ($200 upfront). Official claude.com copy includes Claude Code, Design/Slides/Docs, projects, more models, and Claude for Microsoft 365.

  Claude Max: From $100/Month

  Max starts at $100/month with a choice of 5x or 20x more usage than Pro per five-hour session. The pricing card prints “from $100” and does not list a separate 20x dollar amount. Anthropic’s Help Center lists Max 5x at $100/month and Max 20x at $200/month for web checkout. Mobile store prices may differ. Max is monthly billing only.

  Claude Team: From $20/Seat/Month

  Official claude.com Team seats (USD): Standard $20/seat annual or $25 monthly; Premium $100/seat annual or $125 monthly. Premium is 5× Standard usage. Enterprise on the same page is $20/seat plus usage at API rates, billed annually. Anthropic said on October 7 it will roll out monthly Platform credits this week: Max 5x $100, Max 20x $200, Team up to $500 pooled. That is an announced credit, not a lower seat price.

  Claude API: Pay Per Token

  API access is separate from seats. You pay per million tokens (MTok) for input and output. Current first-party list (October 8, 2026):

  Model	Input / MTok	Output / MTok	Notes
  Haiku 5.5	$0.10 / $0.50	$0.50 / $2.50	Under / over 100k prompt tokens. Launched Oct 7, 2026
  Haiku 4.5	$1	$5	Still listed
  Sonnet 5.5	$2	$10	Cache reads now $0.10 (was $0.20)
  Sonnet 5	$2	$10	Cache reads still $0.20
  Sonnet 4.6	$3	$15	Legacy SKU still listed
  Opus 5.5	$4	$20	Cache reads $0.20
  Opus 5 / 4.8	$5	$25	Cache reads $0.50
  Fable 5.1	$10	$50	Cache reads $0.25

  Batch API is 50% off input and output. Prompt caching: 5-minute write 1.25× input, 1-hour write 2×. Cache reads are 0.05× on Sonnet 5.5 and Opus 5.5, 0.1× on Sonnet 5 and Haiku 4.5, and $0.01 / $0.05 on Haiku 5.5. Full schedule: Claude API pricing & token rates.

  Quick Cost Comparison Table

  Product	Price	Best for
  Free	$0	Light chat, no Claude Code
  Pro	$20/mo ($17 annual)	Daily chat + Claude Code
  Max 5x	$100/mo	Heavy interactive use
  Max 20x	Help Center $200/mo (web)	Very heavy interactive use
  Team Standard	$20–$25/seat	Shared workspace, light seats
  Team Premium	$100–$125/seat	Power seats (5× Standard)
  Enterprise	$20/seat + usage	Admin, SSO, usage billing
  API (Haiku 5.5 → Fable)	$0.10–$10 input / MTok	Apps, automation, CI

  Seat vs API: which bill are you on?

  If you…	You pay…	Read next
  Chat in Claude.ai / use interactive Claude Code	Seat plan usage limits	Claude Code billing & credit pools
  Run claude -p, Agent SDK, or GitHub Actions on a subscription	Separate Agent SDK monthly credit	Dual-bucket billing
  Build on an API key	Pay-per-token API rates	API token rates

  How Claude usage limits actually work

  The seat price buys a usage window, not a fixed number of messages. Limits reset on a rolling five-hour session, and paid plans add a weekly cap on top.

  On claude.com/pricing, checked October 8, 2026, Free covers everyday questions. Pro includes at least 5x more usage per five-hour session than Free. Max includes 5x or 20x more usage per five-hour session than Pro. Chat on the web, the desktop app, mobile, and Claude Code draw from one pool. The Max plan Help Center article says the weekly limit resets on a fixed day and time for the account. Settings, then Usage, shows the session meter and the weekly reset.

  When the meter runs out, wait for the reset, move to a higher plan, or turn on usage credits and the extra work bills at standard API rates.

  Claude API pricing, by model

  The API is a separate bill from the seat. You pay per million tokens, and on every current model the output line costs more than the input line.

  Current model	Input / MTok	Output / MTok
  Haiku 5.5 (≤100k / >100k)	$0.10 / $0.50	$0.50 / $2.50
  Sonnet 5.5	$2	$10
  Opus 5.5	$4	$20
  Fable 5.1	$10	$50

  Haiku 4.5 remains $1 and $5. Sonnet 5 remains $2 and $10. Sonnet 4.6 remains $3 and $15. Opus 5 remains $5 and $25. The Batch API takes 50% off: Haiku 5.5 batch is $0.05 and $0.25 under 100k, Sonnet 5.5 is $1 and $5, Opus 5.5 is $2 and $10, Fable 5.1 is $5 and $25. US-only inference on Claude 4.6 and later is 1.1x. Fast mode prices Opus 5.5 at $8 and $40. Haiku 5.5 is the model that raises the rate above 100,000 prompt tokens. Other Claude 4.6 and later models keep one rate through the 1M window.

  When prompt caching saves money

  A 5-minute cache write is 1.25 times base input and a 1-hour write is 2 times. A cache hit on Sonnet 5.5 is $0.10 per million tokens, down from $0.20 on October 7. Opus 5.5 hits stay $0.20. Fable 5.1 hits stay $0.25. Haiku 5.5 hits are $0.01 under 100k and $0.05 over. A 5-minute write is $0.125 for Haiku 5.5 under 100k, $2.50 for Sonnet 5.5, $5 for Opus 5.5, and $12.50 for Fable 5.1.

  Frequently Asked Questions

  How much does Claude AI cost per month?

  Free is $0. Pro is $20 monthly or $17 annual. Max starts at $100/month, with a choice of 5x or 20x Pro usage per five-hour session. The Help Center lists the 20x tier at $200/month on the web. Team starts at $20/seat annual. Enterprise is $20/seat plus API-rate usage. API bills separately per token.

  Related on Tygart Media: API rates · Haiku 5.5 list.

  Part of the complete guide: Claude Pricing, Plans & Limits

  June 4, 2026

• 

  Claude Team Pricing: Standard vs Premium Seats (2026)

  Claude’s Team plan is built for groups of 2 to 150 people who need collaborative AI access with centralized administration. As of October 2026, Anthropic offers two seat types within the Team plan — Standard and Premium — with meaningfully different usage allowances and price points. This guide breaks down exactly what each seat type includes, what the real costs look like, and how to decide which mix works for your organization.

  Direct Answer (October 2026): Claude Team pricing offers two options (2-seat minimum): Standard Team ($25/seat/mo or $20 annual) with bundled usage and shared workspaces, and Premium Team ($125/seat/mo or $100 annual) which includes expanded Claude Code CLI capacity, GitHub/GitLab integration, and automated developer tooling.

  Team Plan Pricing Overview

  

  The Team plan uses per-seat pricing with two tiers. Standard seats cost $25 per seat per month on monthly billing, or $20 per seat per month on annual billing. Premium seats cost $125 per seat per month on monthly billing, or $100 per seat per month on annual billing. You can mix and match seat types within the same organization — not everyone needs the same usage level.

  For a 10-person team on annual billing with 7 Standard and 3 Premium seats, the monthly cost would be (7 × $20) + (3 × $100) = $440/month, or $5,280/year. Compare that to putting all 10 on Standard ($200/month) or all 10 on Premium ($1,000/month) to see why the mix-and-match model matters.

  What Standard Seats Include

  

  Standard seats include all Claude features — chat across web, iOS, Android, and desktop — plus more usage than what individual Pro subscribers get. Standard seat holders can access Claude Code and Claude Cowork, connect Microsoft 365, Slack, and other integrations, and use Enterprise search across the organization. They get SSO, admin controls, and the enterprise desktop app deployment. The key differentiator from Pro is the organizational layer: centralized billing, admin controls, and content that isn’t used for model training by default.

  What Premium Seats Add

  Premium seats provide approximately 5x the usage of Standard seats. This is designed for power users — engineers running Claude Code all day, researchers doing deep analysis sessions, content teams producing high volumes of output. Premium seats are the Team-plan equivalent of individual Max plans, but with all the organizational infrastructure (SSO, admin controls, no training on content) included.

  Team Plan vs Individual Pro/Max Plans

  The question many organizations face: should each person just buy their own Pro or Max subscription? The Team plan adds several capabilities that individual plans lack. Central billing means one invoice instead of individual expense reports. SSO and domain capture ensure that everyone in your organization uses the managed account. Admin controls let you manage connectors and desktop app deployment centrally. Content is not used for model training by default — individual free and Pro accounts have an opt-out option, but Team accounts are opted out by default. Enterprise search lets team members search across organizational knowledge.

  Team Plan vs Enterprise Plan

  The Team plan caps at 150 users. If you need more, or if you need features like SCIM provisioning, audit logs, compliance API, custom data retention, HIPAA readiness, IP allowlisting, or role-based access with fine-grained permissions, you need Enterprise. Enterprise is published at $20/seat/month plus API usage, billed annually — contact Anthropic sales for volume terms.

  How to Choose Between Standard and Premium Seats

  

  Start with Standard seats for everyone and monitor usage. If specific team members consistently hit rate limits — especially developers using Claude Code heavily or analysts running extended research sessions — upgrade those individuals to Premium seats. The mix-and-match model means you don’t need to over-provision. A typical pattern for a 20-person team might be 4-5 Premium seats for heavy users and 15-16 Standard seats for everyone else.

  Frequently Asked Questions

  What is the minimum team size for Claude Team?

  The Claude Team plan requires a minimum of 2 seats. You can mix Standard and Premium seats within that minimum.

  Can I switch between Standard and Premium seats?

  Yes. Administrators can upgrade individual seats from Standard to Premium or downgrade from Premium to Standard. Changes take effect on the next billing cycle.

  Does Claude Team include Claude Code?

  Yes. Both Standard and Premium Team seats include access to Claude Code and Claude Cowork.

  Is my team’s data used for training on the Team plan?

  No. Content is not used for model training by default on the Claude Team plan.

  
  

  Related: Claude AI Pricing (2026) — every plan, API rate, and the cost calculator

  💼 Deploying Claude or AI Infrastructure in Your Business?

  At Tygart Media, we engineer custom Model Context Protocol (MCP) servers, multi-model content pipelines, and AI operational systems. Explore our Claude AI Team Implementation Services or check out our complete Restoration Operations & AI Kit.

  Part of the complete guide: Claude Pricing, Plans & Limits

  June 4, 2026

• 

  Anthropic Console: Developer Quickstart Guide (2026)

  The Anthropic Console at platform.claude.com is where developers manage everything related to the Claude API. Whether you’re generating your first API key, tracking token usage, setting spend limits, or managing team workspaces, the console is your control center. This guide walks through every section of the console as it exists in June 2026.

  What Is the Anthropic Console?

  The Anthropic Console — also called the Anthropic Developer Console — is the web-based dashboard at platform.claude.com where you manage your Claude API access. It is separate from claude.ai, which is the consumer chat interface. The console handles API key generation, billing and payment, usage monitoring, workspace and team management, rate limit visibility, and access to developer documentation. Think of claude.ai as where you use Claude, and platform.claude.com as where you build with Claude.

  Getting Started: Creating an Account

  

  Navigate to platform.claude.com and sign up with your email or Google account. You’ll need to add a payment method before you can make API calls. Anthropic uses a prepaid credit system — you load credits onto your account and API calls draw from that balance. New accounts start with a default spending limit that increases as you build usage history.

  API Keys: Creating and Managing

  

  API keys are generated in the console under the API Keys section. Each key begins with “sk-ant-” and should be treated as a secret credential. Best practices include creating separate keys for different applications or environments (development, staging, production), naming keys descriptively so you can identify which application uses which key, rotating keys periodically, and never committing keys to source control. If a key is compromised, you can revoke it immediately from the console without affecting your other keys.

  Billing and Usage Monitoring

  The billing section shows your current credit balance, spending history, and usage breakdown by model. You can view costs broken down by Opus, Sonnet, and Haiku usage, see daily and monthly spending trends, set up automatic credit top-ups, and configure spending alerts. Usage is reported in tokens — both input tokens (what you send to Claude) and output tokens (what Claude generates). The console shows real-time and historical usage data with charts that break down costs by model, feature, and time period.

  Workspaces and Team Management

  For organizations, the console supports workspace-level management. You can invite team members with specific roles, set per-user or per-workspace spending limits, view aggregated usage across your organization, and manage API keys at the workspace level rather than individually. This is particularly useful for agencies or development teams where multiple people need API access but you want centralized billing and usage controls.

  Rate Limits and Service Tiers

  

  The console displays your current rate limits, which depend on your service tier. Anthropic offers three service tiers: Priority for when time, availability, and predictable pricing matter most; Standard as the default tier for both piloting and scaling everyday use cases; and Batch for asynchronous workloads processed together at 50% off. Rate limits increase as your account matures and your spending history grows. The console shows your current limits for requests per minute and tokens per minute across each model.

  Developer Documentation Access

  The console links directly to Anthropic’s developer documentation at platform.claude.com/docs, which includes API reference with endpoint specifications, SDK guides for Python and TypeScript, prompt engineering best practices, tool use and function calling documentation, vision and multimodal capabilities, and integration guides for AWS Bedrock, Google Cloud Vertex AI, and Microsoft Foundry.

  Console vs Claude.ai: Key Differences

  A common point of confusion: the Anthropic Console (platform.claude.com) is not the same as Claude.ai. Claude.ai is the consumer-facing chat interface where individuals and teams interact with Claude through conversation. The console is the developer-facing dashboard for API management, billing, and infrastructure. You can have accounts on both — your Claude.ai subscription (Free, Pro, Max, Team, Enterprise) is separate from your API credits on the console.

  Related on Tygart Media: API quickstart · Message Batches · how to use Claude.

  Frequently Asked Questions

  How do I access the Anthropic Console?

  Go to platform.claude.com and sign in with your Anthropic account. If you don’t have one, you can create a free account and add billing information to start making API calls.

  Is the Anthropic Console free to use?

  The console itself is free. You only pay for API usage based on the tokens consumed. There is no monthly fee for console access — you pay per token as you use the API.

  What is the difference between the Anthropic Console and the Anthropic Developer Console?

  They are the same thing. “Anthropic Console” and “Anthropic Developer Console” both refer to the dashboard at platform.claude.com where developers manage API keys, billing, and usage.

  Can I set spending limits on the Anthropic Console?

  Yes. The console allows you to set both per-workspace and per-user spending limits. You can also configure automatic credit top-ups and spending alerts to stay within budget.

  
  

  >Part of the complete guide: Working with the Anthropic API

  June 4, 2026

• 

  llms-full.txt vs llms.txt: Why AI Agents Crawl It More (2026)

  Last verified: October 11, 2026. AI crawler user-agents and llms.txt conventions shift quickly — always confirm bot names and file conventions against the current provider docs and your own server logs before relying on them.

  Most conversations about AI crawlability focus on one file: llms.txt. But if you look at what Anthropic, Vercel, and LangGraph actually ship – and what GEO crawler research found AI agents fetching most – the file that matters more is its companion: llms-full.txt.

  Here’s the practical reality: llms.txt is the map. llms-full.txt is the territory. And in 2026, the agents that matter for citation traffic are fetching the territory.

  The Full File Family You Probably Don’t Know About

  The original llms.txt proposal – published by Jeremy Howard in September 2024 – defined one file. Implementers built the rest. The complete family as of mid-2026 is four files, but most sites only need two:

  File	What’s in it	When to use
  /llms.txt	Curated index – H1, summary, link sections	Always. The orientation layer.
  /llms-full.txt	Full content of every linked page, concatenated as Markdown	When you want a model to deep-ingest your docs in a single fetch
  /llms-ctx.txt	Pre-expanded context without URLs	FastHTML-style implementations
  /llms-ctx-full.txt	Pre-expanded context with URLs preserved	Same, but URL-aware

  The pattern that works – and the one Anthropic, Vercel, and LangGraph all run – is the index + export pair: llms.txt for orientation, llms-full.txt for deep ingestion.

  Why llms-full.txt Gets Crawled More

  

  GEO researchers analyzing AI crawler behavior – including work cited by Profound – have noted that agents from Microsoft, OpenAI, and others tend to fetch llms-full.txt more frequently than llms.txt when both are present. The working explanation is structural: when a file contains the full content, it removes one retrieval step. An agent that fetches llms-full.txt gets everything it needs in a single HTTP request instead of fetching the index, parsing the links, then fetching each linked page individually. This is consistent with how developer documentation platforms like Mintlify describe the behavior of IDE agents operating under tight latency budgets.

  For IDE agents (Cursor, Continue, Cline) and MCP integrations, this is even more pronounced. These tools are operating under tight context windows and latency budgets. A single fetch that returns a clean Markdown blob of your entire docs is structurally preferable to a multi-step crawl.

  The implication: if you’ve shipped llms.txt but not llms-full.txt, you’ve done half the job.

  How to Build llms-full.txt

  

  The construction logic is simple: take every URL in your llms.txt, fetch each page, strip HTML to Markdown, and concatenate. In practice, most sites do this in their build pipeline.

  Here’s the minimal Node.js pattern:

  const fs = require('fs');
  const fetch = require('node-fetch');
  const TurndownService = require('turndown');
  const turndown = new TurndownService();
  
  async function buildLlmsFullTxt(llmsIndexPath, outputPath) {
    const index = fs.readFileSync(llmsIndexPath, 'utf8');
    const urlRegex = /\[.*?\]\((https?:\/\/[^\)]+)\)/g;
    const urls = [...index.matchAll(urlRegex)].map(m => m[1]);
  
    let output = '';
    for (const url of urls) {
      const res = await fetch(url);
      const html = await res.text();
      const markdown = turndown.turndown(html);
      output += \n\n---\n# Source: \n\n;
    }
  
    fs.writeFileSync(outputPath, output);
    console.log(Built llms-full.txt:  pages,  chars);
  }
  
  buildLlmsFullTxt('./public/llms.txt', './public/llms-full.txt');

  One constraint to manage: keep llms-full.txt under roughly 200,000 tokens (about 150K words, around 700KB). That’s the threshold where most models can ingest the file in a single context window. If your docs are larger, segment by product or language the way Supabase does – llms-full-api.txt, llms-full-guides.txt – and list the segmented files in your main llms.txt.

  The 2026 robots.txt Stack That Completes the Picture

  

  Shipping llms.txt and llms-full.txt is the visibility layer. The access-control layer is robots.txt – and it changed significantly in Q2 2026.

  The key development: Anthropic split its crawler into two separate user-agents. ClaudeBot is the training scraper (high bandwidth, no citation value – block it). Claude-Web is the live-retrieval agent that fetches pages to answer Claude.ai user queries in real time (allow it, because it drives citation traffic). Brands that blanket-block “all Anthropic crawlers” lose Claude citations entirely.

  Meta also shipped two active training scrapers in March 2026 – FacebookBot and Meta-ExternalAgent – at GPTBot-level crawl volume. Most sites have no rules for them yet.

  Here’s the 2026 template:

  # BLOCK: Training scrapers - high bandwidth, zero referral value
  User-agent: GPTBot
  Disallow: /
  
  User-agent: CCBot
  Disallow: /
  
  User-agent: ClaudeBot
  Disallow: /
  
  User-agent: FacebookBot
  Disallow: /
  
  User-agent: Meta-ExternalAgent
  Disallow: /
  
  # OPT OUT: Google Gemini training (keeps Search indexing intact)
  User-agent: Google-Extended
  Disallow: /
  
  # ALLOW: Live-retrieval agents - drive citation traffic
  User-agent: OAI-SearchBot
  Allow: /
  
  User-agent: ChatGPT-User
  Allow: /
  
  User-agent: Claude-Web
  Allow: /
  
  User-agent: anthropic-ai
  Allow: /
  
  User-agent: PerplexityBot
  Allow: /

  One important caveat on robots.txt enforcement: aggressive training scrapers often ignore the file or spoof their user-agents. The robots.txt rules signal intent and work for compliant bots; a WAF rule at the edge is the only deterministic block for non-compliant crawlers.

  The Honest State of the Technology

  The SERanking study of 300,000 domains (November 2025) found no measurable correlation between having llms.txt and being cited by ChatGPT, Claude, Gemini, or Perplexity. Google’s John Mueller compared the file to the deprecated keywords meta tag – something site owners declare but that search systems derive from the content itself.

  None of that means you shouldn’t ship both files. The cost is low, the optionality is real, and the IDE-agent ecosystem (Cursor, Continue, Cline) does actively use llms.txt. But the robots.txt work is the lever that moves outcomes today. The llms.txt + llms-full.txt pair is infrastructure investment – you want to be correct when major LLM providers start honoring it, and building the build pipeline now costs far less than retrofitting it later.

  The practical sequence for a site that hasn’t done this yet:

  1. Update robots.txt first. Add the Q2 2026 user-agent rules above. This takes twenty minutes and immediately affects how training scrapers treat your content.
  2. Ship llms.txt. Curated index, 20-50 priority pages, one-sentence description per link, sections in priority order.
  3. Build llms-full.txt. Concatenated Markdown of every linked page, under 200K tokens. Run it in your build pipeline so it stays current.
  4. Verify both files are served correctly. curl -I https://yoursite.com/llms.txt should return 200 with Content-Type: text/plain. A 404 on either file is the most common implementation error.
  5. Add an access-log check. Once per month, grep your logs for requests to /llms.txt and /llms-full.txt by user-agent. You want to see live-retrieval agents (Claude-Web, OAI-SearchBot, PerplexityBot) in the results – not just training scrapers.

  The goal isn’t to optimize for a standard that isn’t fully adopted yet. It’s to build the infrastructure correctly now, while the field is still forming, so that adoption changes work in your favor rather than requiring catch-up.

  Related Reading

  • How AI Engines Actually Cite Your Content: Grounding and GEO Guide
  • AEO Intent Classification: The Four-Query Framework for AI Engines
  • How to Connect Any Tool to Claude with MCP: Complete Setup Guide
  • Notion MCP Setup with Claude: Complete Config + Undocumented Errors
  • How to Connect Claude Code to Postgres via MCP (The Right Way)
  • The AI Operator’s Stack: Running a Multi-Brand Content Machine
  • How I Made a $400 Laptop More AI-First Than a Copilot+ PC

  Frequently Asked Questions

  What is the difference between llms.txt and llms-full.txt?

  llms.txt is a curated index — an H1, a summary, and link sections that orient an AI agent to your site. llms-full.txt is the full content of every linked page concatenated as Markdown, so an agent can deep-ingest your documentation in a single fetch. The index is the map; the full file is the territory.

  Why do AI agents crawl llms-full.txt more often than llms.txt?

  Fetching llms-full.txt removes a retrieval step: the agent gets everything in one HTTP request instead of fetching the index, parsing links, and fetching each page individually. For IDE agents like Cursor, Continue, and Cline operating under tight latency and context budgets, a single clean Markdown blob is structurally preferable to a multi-step crawl.

  How big should llms-full.txt be?

  Keep it under roughly 200,000 tokens (about 150K words, around 700KB) so most models can ingest it in a single context window. If your docs are larger, segment by product or language — for example llms-full-api.txt and llms-full-guides.txt — and list the segmented files in your main llms.txt.

  Does having llms.txt actually improve AI citations?

  Not measurably on its own. A November 2025 SERanking study of 300,000 domains found no correlation between having llms.txt and being cited by ChatGPT, Claude, Gemini, or Perplexity, and Google’s John Mueller compared it to the deprecated keywords meta tag. The lever that moves outcomes today is robots.txt configuration; llms.txt and llms-full.txt are low-cost infrastructure for when adoption grows.

  Which AI crawlers should I allow in robots.txt in 2026?

  Allow live-retrieval agents that drive citation traffic — Claude-Web, OAI-SearchBot, ChatGPT-User, anthropic-ai, and PerplexityBot. Block high-bandwidth training scrapers with no referral value such as GPTBot, CCBot, ClaudeBot, FacebookBot, and Meta-ExternalAgent, and opt out of Google-Extended to skip Gemini training while keeping Search indexing intact.

  June 3, 2026

• 

  Claude Code vs Codex CLI (2026): A Hands-On Head-to-Head

  Last verified: June 2026.

  Both Claude Code and OpenAI Codex CLI are terminal-native coding agents: you run them inside a repo, they read your files, edit code, run commands, and iterate. I run both daily on real projects. This is the head-to-head I wish existed when I was deciding which one to make my default. No benchmarks-chasing, just install commands, config files, pricing math, and where each one actually earns its keep. For the broader toolchain these slot into, see our AI operator’s stack.

  Claude Code vs Codex CLI: the short answer

  

  If you want one sentence: Claude Code is the more mature agentic harness (subagents, hooks, skills, deep MCP, a flat-rate plan that makes heavy use affordable), while Codex CLI is the leaner, cheaper-per-token option with strong raw coding from the GPT-5.x line and a tight sandbox model. Most teams that live in the terminal all day end up on Claude Code for the workflow tooling; people who want a fast, low-cost agent on top of an existing OpenAI subscription reach for Codex.

  The honest version: they are closer than tribal arguments suggest. The deciding factors are almost never “which model is smarter this week” and almost always pricing structure, sandbox defaults, and how much workflow scaffolding you need.

  How do you install each one?

  

  Claude Code installs from npm and runs as the claude command:

  npm install -g @anthropic-ai/claude-code
  cd your-project
  claude

  First run walks you through OAuth login (Pro/Max plan) or an ANTHROPIC_API_KEY. On Windows it runs natively in PowerShell now, though a lot of operators still prefer it under WSL for fewer path headaches.

  Codex CLI ships an install script and is also on npm:

  # Mac / Linux
  curl -fsSL https://chatgpt.com/codex/install.sh | sh
  
  # Windows (PowerShell)
  powershell -ExecutionPolicy ByPass -c "irm https://chatgpt.com/codex/install.ps1 | iex"
  
  # or via npm
  npm install -g @openai/codex

  Then codex in your repo. Auth is either a ChatGPT login (Plus/Pro/Business) or an OpenAI API key via codex login. Both tools are open-source clients hitting hosted models, so the install is the easy part; the model access is what you are really buying.

  Which models do they run in 2026?

  Claude Code defaults to the current Claude flagship. As of June 2026 that is Opus 4.8 (legacy — still listed) for the hardest reasoning, with Sonnet 4.6 (legacy — still listed) as the fast everyday workhorse and Haiku 4

  Lineup currency (Sept 2026): Current API list (Sept 2026, verified): Sonnet 5 $2/$10, Opus 5.5 $4/$20, Haiku 4.5 $1/$5, Fable 5.1 $10/$50. Legacy (still listed on Anthropic’s card): Opus 4.8 $5/$25, Sonnet 4.6 $3/$15.

  .5 for cheap, high-volume calls. You switch in-session with /model. Opus 4.8 also exposes reasoning-effort levels (high is the default; xhigh and max push deeper on gnarly problems at higher token cost).

  Codex CLI runs the GPT-5.x coding line. GPT-5.5 is the current recommended default for complex coding and agentic work, GPT-5.4-mini is the faster/cheaper option for light tasks and subagents, and GPT-5.3-Codex remains a strong coding-tuned choice. Pick the model with codex -m gpt-5.5 or set it in your config.

  Practical read: on a clean, well-specified function both produce good code. The gap shows up on long, multi-file refactors where the agent has to hold a lot of context and recover from its own mistakes. That is a harness problem as much as a model problem, which is the next section.

  What about workflow features: subagents, hooks, and config?

  This is where Claude Code is currently ahead, and it is the real reason it tends to win for power users.

  • Subagents – Claude Code spawns isolated sub-sessions with their own context window, tool restrictions, and prompts. Great for “go research this in parallel while the main thread keeps coding.” Codex has a lighter subagent concept (often pointed at GPT-5.4-mini to keep cost down) but it is less fleshed out.
  • Hooks – Claude Code fires deterministic scripts at lifecycle points (PreToolUse, UserPromptSubmit, and more). These run real code, so they cannot hallucinate: you can hard-block a dangerous command, auto-format on every edit, or inject context before the model sees a prompt. Codex leans on its approval/sandbox policy and execpolicy rules instead of a general hook system.
  • Skills and slash commands – In Claude Code, custom slash commands have merged into skills; /your-command still works and skills add reusable, packaged capabilities. Codex uses prompt files and profiles rather than a skills layer.
  • Project memory – Both read a project instruction file. Claude Code uses CLAUDE.md; Codex uses AGENTS.md (checked in a fallback order including AGENTS.override.md and .agents.md). Keep these tight: architecture, conventions, and the few rules the agent keeps forgetting.

  Codex’s config story is clean if you like a single file: ~/.codex/config.toml holds your model, approval policy, sandbox mode, MCP servers, and named profiles you switch with codex --profile work. Claude Code spreads config across ~/.claude/ and .claude/settings.json plus per-project files, which is more surface area but more granular control.

  How do the sandbox and approval models compare?

  This matters more than most comparisons admit, because it governs how much the agent can do without asking.

  Codex CLI has an explicit, well-documented sandbox. Sandbox modes run from read-only to workspace-write (edit files in the project, network off by default) up to full access, paired with approval policies like untrusted and on-request. On Windows the native sandbox can run unelevated or elevated. The mental model is clear: pick how much rope, then approve escalations.

  Claude Code manages permissions through allow/deny rules and modes (including a plan mode that reasons without touching files, and an auto-accept mode for trusted loops). Combined with PreToolUse hooks you can build a strict policy, but it is more “assemble it yourself” than Codex’s preset sandbox tiers.

  If you are dropping an agent onto an unfamiliar or sensitive repo, start read-only in both. Codex makes that posture a one-flag default; Claude Code gives you finer-grained control once you invest in the config.

  Do both support MCP?

  

  Yes, and this is a genuine tie that matters. Both speak the Model Context Protocol, so you can wire in the same external tools, databases, and APIs. Codex registers STDIO or streaming-HTTP MCP servers in ~/.codex/config.toml and launches them at session start. Claude Code adds servers via claude mcp add or JSON config. If you have already built MCP integrations, neither tool locks you out. New to MCP, start with our Claude MCP setup guide and the Notion MCP setup walkthrough.

  What does each one cost?

  Pricing is where the decision often gets made, so here are the real numbers as of June 2026.

  Claude Code plans:

  • Pro – $20/mo: Sonnet 4.6 plus some Opus, roughly enough for focused daily sessions, not all-day heavy use.
  • Max 5x – $100/mo: much larger windows, real Opus headroom.
  • Max 20x – $200/mo: the heavy-user tier; effectively flat-rate firehose access.
  • API pay-as-you-go: Opus 4.7 about $5/$15 per million input/output… (legacy (still listed) Opus tier runs higher), Sonnet 4.6 (legacy — still listed) $3/$15, Haiku 4.5 $1/$5.

  Codex CLI: Included in ChatGPT Plus/Pro/Business plans (usage g

  Lineup currency (Sept 2026): Current API list (Sept 2026, verified): Sonnet 5 $2/$10, Opus 5.5 $4/$20, Haiku 4.5 $1/$5, Fable 5.1 $10/$50. Legacy (still listed on Anthropic’s card): Opus 4.8 $5/$25, Sonnet 4.6 $3/$15.

Codex CLI: Included in ChatGPT Plus/Pro/Business plans (usage governed by your plan’s limits), or pay-as-you-go on the API. GPT-5.3-Codex runs about $1.75 per million input / $14 per million output, with cheaper input on cached tokens. The mini model is far cheaper for light work.

The structural difference: Claude Code’s Max plans are flat-rate, which is why heavy users love them. People have tracked billions of tokens that would cost five figures on API metering but ran around a few hundred dollars on Max. Codex’s per-token rates are lower per unit and great if your usage is bursty or already bundled into a ChatGPT subscription, but a true all-day agent habit can run up metered cost faster than a flat plan. Estimate your monthly token volume honestly, then do the arithmetic both ways.

So which coding agent should you actually use?

Pick Claude Code if you want the deepest agentic workflow (subagents, hooks, skills), you are a heavy daily user who benefits from the flat-rate Max plan, or you need fine-grained, scriptable control over what the agent can do. It is the more complete operator’s harness in 2026.

Pick Codex CLI if you want lower per-token cost, you already pay for ChatGPT and want to use that allowance, you like the clean preset sandbox/approval model, or you simply prefer the GPT-5.x output style. It is lean, fast to stand up, and genuinely capable.

The move a lot of us make: run both. They are cheap relative to engineer time, they share MCP servers, and they have different failure modes. When one gets stuck in a loop on a hard bug, handing the same task to the other with fresh context often breaks the logjam. If you are weighing terminal agents against IDE-native ones, our Claude Code vs Cursor breakdown covers that axis.

Related on Tygart Media: Claude Code vs Cursor · Claude Code getting started · coding benchmarks.

Frequently asked questions

Is Claude Code or Codex CLI better for large refactors?

Claude Code tends to hold up better on long multi-file refactors, mostly because of subagents and hooks that keep context organized and catch mistakes deterministically. Codex can do it too, especially with GPT-5.5, but you lean harder on tight AGENTS.md instructions and approval gates.

Can I use Codex CLI without a ChatGPT subscription?

Yes. Run codex login with an OpenAI API key and you pay per token instead of through a ChatGPT plan. Same for Claude Code with an ANTHROPIC_API_KEY if you would rather meter than subscribe.

Do they work on Windows natively?

Both do in 2026. Claude Code runs in PowerShell (many operators still prefer WSL for cleaner paths), and Codex CLI has a native Windows installer plus a Windows sandbox with unelevated/elevated modes. Watch out for shells that mangle /tmp or C: style paths in arguments.

What is the single biggest difference?

Pricing structure and workflow depth. Claude Code offers flat-rate Max plans and a richer harness (subagents, hooks, skills); Codex offers lower per-token rates and a cleaner preset sandbox. Model quality is close enough that those two factors usually decide it.

Which model do they run by default?

Claude Code defaults to the legacy (still listed) Claude flagship (Opus 4.8 (legacy — still listed) as of June 2026, with Sonnet 4.6 (legacy — still listed) for everyday speed). Codex CLI recommends GPT-5.5 for complex work, with GPT-5.4-mini and GPT-5.3-Codex as alternatives

Lineup currency (Sept 2026): Current API list (Sept 2026, verified): Sonnet 5 $2/$10, Opus 5.5 $4/$20, Haiku 4.5 $1/$5, Fable 5.1 $10/$50. Legacy (still listed on Anthropic’s card): Opus 4.8 $5/$25, Sonnet 4.6 $3/$15.

. Switch in-session with /model or the -m flag.

How do I get either tool cited or surfaced by AI engines for my own docs?

That is a content question, not a tooling one. The same structure that makes this page answerable, short factual answers, question-shaped headers, and a visible FAQ, is what AI engines reward. See how AI engines cite content for the full playbook.

>Part of the complete guide: Claude vs the Field