Samprix

Methodology & sources

Where our numbers come from, how often we check them, and how the tools work them out.

Our rules for data

  1. Primary sources only. Prices, plan limits and context windows come from the provider’s own pricing pages, documentation or help center, not from news articles, forums or other comparison sites.
  2. Every figure is dated. Each figure is stored with its source URL and the date we last read that page. Pages show a “last checked” date.
  3. No guessing. If a provider doesn’t publish a number (for example, Anthropic doesn’t publish a context window for Claude’s Free plan), we leave it out rather than estimate it.
  4. Estimates are labeled. Anything calculated rather than measured is marked as approximate.

How often we check

  • API prices: daily and automatically, from OpenAI’s, Anthropic’s and Google’s API pricing pages. As with context windows, a price’s “last checked” date only moves forward when the page confirms it.
  • Chatbot context windows: daily and automatically, where the provider’s page can be read by our checker (currently Claude and Gemini). The checker only moves a figure’s “last checked” date forward when the page confirms it; anything it can’t confirm is left as it was and reviewed by hand. ChatGPT’s figures are checked by hand, monthly.
  • API model context windows: daily and automatically, from each model’s own documentation page at OpenAI, Anthropic and Google. The same rule applies: the date only moves forward when the page confirms the figure. Each model’s page is linked in the context window checker.
  • Subscription prices: daily and automatically for Claude and Gemini. OpenAI’s pricing page and help center block automated checks, so ChatGPT’s prices are checked by hand, monthly.
  • Plan details (what each plan includes): monthly, and whenever a provider announces a change. These are reviewed by hand and dated separately from prices.
  • Local AI hardware and models: monthly, by hand. A product’s memory doesn’t change once it ships, so the monthly check is mostly for new cards, Macs and models.

Current sources

Chatbot context windows (used by the token counter), last checked Oct 13, 2026:

API prices (used by the API cost calculator), last checked Oct 13, 2026:

Subscription prices (used by the AI subscription comparison), last checked Oct 13, 2026:

Hardware memory and model files (used by What AI Can My Computer Run? and the LLM VRAM Calculator), last checked Oct 2, 2026:

How the tools calculate

Token counts

We count tokens with OpenAI’s open-source o200k_base tokenizer, which OpenAI’s tiktoken library maps to GPT-4o and the GPT-5 family. It runs in your browser. Anthropic and Google don’t publish tokenizers that can run in a browser, so for Claude and Gemini the count is an approximation and is marked “≈”.

Tokens to words

We use OpenAI’s published rule of thumb for English: one token is about four characters, or three quarters of a word (source). Pages assume 500 words per single-spaced page.

Context window checks

The context window checker adds the tokens in your text to the room you leave for the reply and compares that with each published window. OpenAI and Anthropic publish a total window for input and output, so the reply counts against it; Google publishes the Gemini API’s input and output limits separately, so for those models only your text counts. For local models we use the longest context in the publisher’s configuration file; the app you run the model in decides how much of it is actually loaded. We count with o200k_base; for every other tokenizer, the result is marked “≈”.

Reading and speaking time

Reading time uses 238 words per minute, the average silent reading rate for English non-fiction reported by Brysbaert (2019), How many words do we read per minute? A review and meta-analysis of reading rate, Journal of Memory and Language. Speaking time uses 150 words per minute, a typical presentation pace.

API costs

The API cost calculator multiplies tokens by each model’s published price per million tokens: input and output separately, with the share of input you mark as cached billed at the cached-input price, and batch prices when you choose the Batch API. Anthropic doesn’t list a cached price for batch requests, but its pricing page says the two discounts stack, so we apply both. It uses the standard rate for text; where a model charges more for very long prompts or for audio, we note it next to the model. A month is taken as 30 days. Where a provider publishes a promotional price with an end date, we show the price in force today and when it ends.

Which AI should I use?

The quiz doesn’t test or rank how good each AI’s answers are. It scores the plans within your budget on what the providers publish: a feature counts when a plan’s highlights list it (half when they list it as limited), long documents are scored on the published context window, and the price level is matched to how often you’d use it. The highlight is quoted as the reason. Plans without a published US price are left out, and ties go to the cheaper plan.

The quiz can also rank by app ratings. These are the one set of figures on this site that don’t come from the provider: the star rating and number of ratings shown for each app on the US Apple App Store and on Google Play, read once a day from the stores themselves. A chatbot’s score is the plain average of its two store ratings, and each store’s figure is shown with a link and the date it was read. A store that can’t be read for more than a week is left out until it can. The ratings are users’ opinions of the apps, not a measure of answer quality.

Subscription vs API

The subscription vs API calculator treats each message as one API request whose input is your message plus the conversation so far, since a chat model is sent the whole conversation every time. Averaged over a chat, a message carries half of that chat’s earlier messages and replies. Break-even is the plan’s published monthly price divided by the API cost of one message. Message and reply lengths are your own estimates. Providers don’t publish plan usage limits as message counts, so the comparison is on price alone and doesn’t show where a plan would run out.

Local AI memory

What AI Can My Computer Run? and the LLM VRAM Calculator add up three things: the size of the model file as its download page shows it, the memory its context needs, and an allowance for the program running it. The context memory is worked out from the publisher’s own configuration file: two 16-bit numbers for every layer, key/value head and head width, for each token of context, which is how llama.cpp (and so Ollama and LM Studio) stores it by default. That total is compared with the memory the maker lists for your graphics card or Mac. Models whose publisher keeps the configuration file behind a sign-in are left out.

Two figures in this tool are our own estimates, not published numbers: the allowance for the running program is 0.5 GB, and a model is given at most 75% of memory it shares with the system and other apps (a Mac’s unified memory, or a PC’s RAM when a model doesn’t fit on the graphics card alone). Real use varies with the app and what else is open, so a model shown as just fitting may not. We don’t show speed: nobody publishes tokens-per-second figures we could cite.

Local AI electricity

The local AI electricity cost calculator multiplies the power you enter (in kilowatts) by the hours it runs and your price per kWh. A month is taken as 30 days and a year as 365. Every input is your own: makers publish a graphics card’s maximum power, not what it draws while running a model, and nobody publishes tokens-per-second figures, so we don’t supply either. The figures the page opens with are examples, not typical values. The cost per million tokens is the electricity used in the time your computer takes to generate them at the speed you enter; it is shown next to each API model’s published output price. It leaves out the cost of the hardware and the power used while reading a prompt or sitting idle.

Ollama & LM Studio guide

The setup guide takes every step and system requirement from Ollama’s and LM Studio’s own documentation, linked beside each step. Every day we re-read those pages automatically and confirm that the wording each step relies on is still there; the “Docs last checked” date only moves forward when every step is confirmed. A step whose page has changed is marked on the guide until we’ve re-read the page and updated it by hand. The pictures beside the steps are simplified drawings, not screenshots.

AI image prompt builder

The image prompt builder writes each prompt the way that generator’s own documentation describes: OpenAI’s GPT Image prompting guide for ChatGPT, Google’s Gemini image generation guide for Gemini, and Midjourney’s parameter docs for Midjourney. Those pages are linked under the prompt and re-read automatically every day with the setup guide’s pages, and a format whose page has changed is marked until we’ve updated it. The words for styles, lighting and framing are plain descriptions, not claims about any model, and the picture beside the prompt is a drawing of your choices, not an image any AI made.

Docker image size

The Docker image size calculator never builds or runs a Dockerfile. It reads it, then looks up two kinds of published figure when you change it. The base image’s size is the sum of its layers as its registry lists them (Docker Hub’s tag API, or the registry’s own manifest), which is the compressed download size. Each apt or apk package’s size is the installed size in the Debian, Ubuntu or Alpine package list for that release, read once a day, plus every dependency not already in the image; apt’s recommended packages count unless the Dockerfile turns them off, because apt installs them by default. What an image already has comes from its own build steps as Docker Hub lists them, Debian’s “required” packages, and, for Alpine, the package database inside the release file the image was made from. When you add your project folder or files, COPY steps are measured in your browser, following .dockerignore, and the packages in your lock and project files are sized from the npm registry’s listed unpacked size of each version, from the file list inside the wheel pip would install from PyPI, and from the files dotnet publish copies out of each nuget.org package (leaving out assemblies the runtime image’s shared framework already has, per its published platform manifest). Anything still unknown (downloads, build output) is shown as not counted unless you enter a size. Each tip follows a page in Docker’s, Debian’s, Alpine’s, pip’s or npm’s documentation, linked on the tip and re-read every day with the setup guide’s pages; a tip whose page has changed is marked until we’ve updated it.

Subscription plans

The subscription comparison shows US prices before tax. Plans are grouped by what they cost, not by name. Usage is given in each provider’s own relative terms (for example “5x more usage than Pro”), because none of them publishes exact message limits. Where a provider shows a price only in the visitor’s local currency, we leave the US price out rather than convert or estimate it.

Text cleaning

The AI Text Cleaner removes Markdown syntax and invisible Unicode characters with fixed rules that run in your browser. It never rewrites your words.

Corrections

If you spot an outdated or wrong figure, email admin@samprix.com with a link to the source. We check it against the provider’s page and update both the figure and its “last checked” date.

© 2026 Samprix. Not affiliated with OpenAI, Anthropic or Google.

PrivacyTerms