Free AI APIs: Compare Limits Before You Build

By Rome Thorndike · Updated October 28, 2026

For an application prototype, start by checking Gemini's model-specific free API tier, Cohere's evaluation keys, and the free database plans that fit your retrieval workload. For coding assistance, compare limited free editor plans separately. A free chat account, a paid subscription with included credits, a temporary trial and a free API allowance are different offers.

Several old comparisons are now misleading. Hugging Face's current Inference Providers billing page gives free users no monthly inference credits. GitHub Models has retired. Weaviate now advertises an ongoing free plan rather than only an expiring sandbox. Check the current offer before building a project around a remembered quota.

This guide compares documented access and operating constraints, not hands-on uptime or quality results. The criteria are application access, quota behavior, data terms, storage or compute limits and the path to paid operation. Documentation checked October 28, 2026; AI assisted research and drafting.

Our data: offer comparison, capacity and paid-exit calculations

We compare eleven named services or products, classify their current offer, and calculate a 500-request pilot plus two quota/storage examples. The calculations use stated assumptions rather than claiming observed customer usage. Each helps answer whether a free plan can finish a particular prototype.

Comparison table · Free API access · Vector databases · Coding tools · Quota calculations · Prototype choices · When to upgrade

AI free tiers compared: what is free?

ServiceCurrent offer to checkMain constraintBest evaluation use
Gemini Developer APIFree input/output for eligible model rowsModel-specific quotas and free-tier data termsSmall application and model evaluations
OpenAI APIAccount-specific test access, credits or eligible plan-linked accessModel eligibility, billing route and usage limitsA bounded test with a verified account allowance
Claude APIVerify any account offer; budget normal API charges separatelyA chat account does not establish a general API grantCosted model evaluation
CohereFree evaluation keysTrial call limits and production-key requirementsRetrieval or generation component experiments
Hugging Face Inference ProvidersNo monthly credits for free users in current billing tableCredits purchase or a qualifying paid planCompare specific hosted model/provider routes
GitHub ModelsRetiredFormer playground and inference API unavailableUse another current service
PineconeStarter free planIncluded usage and plan featuresSmall vector-search prototype
Weaviate CloudOngoing free database planObject, memory, disk and collection limitsSmall managed retrieval prototype
GitHub CopilotLimited free individual planFeature/model access and allowanceTry assistance in a development workflow
CursorFree plan with limited AI usageAgent/chat allowance and model availabilityCheck editor compatibility and interaction
Windsurf / DevinFree plan at the current pricing destinationLimited agent quota and model availabilityEvaluate the current desktop/agent workflow

Read this table as a starting shortlist. A free database does not supply a free language model, and a free coding assistant is not a general-purpose inference API for your users. Keep each component's allowance and billing account separate in the architecture.

Gemini API free access

The Gemini pricing page lists free input and output for eligible models, including Gemini 2.5 Flash and Flash-Lite. Its tables distinguish free-tier use of content to improve products from paid-tier handling. Check the exact model, feature and applicable terms before sending private documents.

The quota documentation describes requests per minute, input tokens per minute and requests per day, with limits applied per project. It directs users to their active limits in AI Studio. Creating another API key within the same project does not create a separate project allowance.

Choose the model after defining the task. A short classification experiment and a long-document assistant have different token requirements. Run a small representative sample and inspect whether the free model access supports the needed input types, output format and response quality.

For a shared prototype, design the queue before inviting users. If multiple people submit at once, a per-minute limit can become the bottleneck long before the daily allowance is exhausted. Show a truthful pending or retry state and preserve the user's input so a temporary limit does not become lost work.

OpenAI: verify the account's actual allowance

The OpenAI quickstart describes how to create a key and make an API request. That onboarding process does not establish a universal $5 grant with a fixed expiry for every account. Check the credit balance, permitted models and billing configuration shown to the account you will use.

OpenAI also documents eligible ChatGPT plan usage through Sign in with ChatGPT. That is a specific integration and permission path, not evidence that any backend API key inherits a consumer subscription. Record which route your prototype uses and whose allowance it consumes.

Keep a paid fallback estimate even if a test is covered by credits. The ability to make one request proves connectivity, not that you can serve a public application for free. Do not expose a private API key in frontend code to simplify an experiment; use the service's intended authentication route.

Claude: a chat plan and API billing need separate checks

Anthropic's API pricing documentation provides model and feature rates. Use the applicable account terms to establish whether a promotional balance or plan-linked allowance exists. This comparison does not promise a recurring free Claude API tier to every new account.

For a prototype, set a small explicit spending limit and estimate the sample before running it. If the provider offers account credits, record expiry and eligible services. A balance that covers one model or product should not be silently applied to a different endpoint in the budget.

Manual experiments in a chat interface can help refine a task description. They still do not test the application's request construction, error handling or quota behavior. Complete an API-level pilot before deciding the integration is ready for users.

Cohere evaluation keys

Cohere distinguishes evaluation and production keys. Its current documentation limits trial keys to 1,000 calls per month and gives endpoint-specific rate limits. Some newer model variants need additional production arrangements. Confirm the model and key type rather than treating every Cohere endpoint as having the same allowance.

This can support a focused comparison of an embedding, reranking or generation component. Count calls across the pipeline: one user search may involve an embedding request, a rerank request and a generation request. A monthly call allowance is not automatically the same number of end-user searches.

Use the evaluation to answer a narrow question, such as whether reranking improves the first relevant result. Save the relevant-document labels and outputs. When the experiment succeeds, check production access and cost before making that component a dependency of a public service.

Hugging Face free inference: an important billing change

The current Inference Providers billing table lists no monthly credits for free users. It lists $2 monthly compute credits for PRO users and $2 per seat for Team or Enterprise organizations. Routed requests and custom provider keys have different billing paths.

A free Hugging Face account still helps you discover models and read model cards, but that is separate from paying to run a hosted model. Downloadable weights also need compute. Do not use an old “free inference allowance” in a current cost forecast without checking the account and service.

If you bring a provider key, inspect that provider's limits and invoice. If you route through Hugging Face, inspect the applicable credits and usage. Record both model and hosting provider in your evaluation so a later routing change does not make the results impossible to reproduce.

GitHub Models is retired

GitHub's documentation says GitHub Models was fully retired on July 30, 2026, including the playground, catalog, inference API and bring-your-own-key functionality. It distinguishes that service from GitHub Copilot. Do not start a new prototype using an obsolete GitHub Models tutorial.

If an old project depended on the service, identify the actual model behavior and request format it needs before choosing a replacement. A new endpoint may require different model IDs, authentication and output parsing. Re-run the original evaluation inputs rather than assuming the same prompt will produce the same result.

Free vector databases for a retrieval prototype

A retrieval-augmented application has several costs: embeddings, stored vectors, searches and generated answers. A free database covers only the services included in that plan. Count document chunks after splitting and overlap, because the stored object count can be much larger than the number of source files.

Pinecone Starter

Pinecone's current pricing page lists Starter as free for trying the service and small applications. It now also lists a $20-per-month Builder plan and a Standard plan with a $50 monthly usage minimum. The plan table includes dense, sparse and full-text indexes, so the old blanket claim that Starter has no hybrid-search path should not be reused.

Inspect included usage and the features your prototype needs before choosing the plan. A basic similarity-search demo and a multi-user application with operational requirements are different tasks. Do not infer backups, support commitments or organization controls from the fact that a free index can answer a query.

Before upgrading, estimate both retained data and query load. A small dataset can still generate substantial traffic, while a large static dataset may be searched rarely. Use all relevant usage dimensions to estimate the paid plan.

Weaviate Cloud Free

Weaviate now advertises an ongoing free plan with one cluster per user, 100,000 objects, 1 GB memory, 10 GB disk, one collection and up to three tenants. Its current page also lists separate embedding and Query Agent allowances. This supersedes the old assumption that every free sandbox expires after fourteen days.

Check the object and memory requirements of your actual schema. Vector dimensions, properties and indexing choices affect how much data fits. A plan's maximum object count is not a promise that every object size and configuration will fit within all the other limits simultaneously.

Keep an export of the prototype's source data and index configuration. If you change the model or database later, those records let you rebuild without relying on an expired experiment or an undocumented dashboard setting.

Free coding assistants are a different category

GitHub Copilot has a limited free individual plan and eligibility-based access for some users. Cursor lists limited free agent and chat use. Devin's current pricing destination for Windsurf lists limited free agent usage with unlimited inline edits and Tab completions.

Use these offers to test your development workflow: can you provide context, review a change and run the project's checks? They do not provide a generic pool of API calls for an application you deploy to customers. Keep editor subscriptions out of the server-side model budget unless the product explicitly supports that route.

A useful free-plan trial includes a small bug fix, a feature crossing several files and a behavior-preserving refactor. Compare accepted changes and review effort. A candidate that exhausts its allowance before those tasks are complete has taught you something about capacity, even if the interface works well.

Open-source tools such as Aider can be free to install while using paid model inference. Local models can avoid per-call API charges while consuming hardware and maintenance effort. Use our editor comparison for the environment choice and coding workflow guide for review and testing.

Calculate capacity before relying on a free tier

Requests, tokens and bursts

Suppose a hypothetical service permits 20 requests per minute and 10,000 input tokens per minute. If your typical request contains 2,000 input tokens, the token allowance supports only five such requests per minute: 10,000 / 2,000. The token limit binds before the request limit. These are illustrative values, not a quote for a provider.

Now suppose ten users submit that request together. Sending all ten immediately requires 20,000 input tokens, twice the example allowance. A queue can spread the work, but it changes the wait time. If the product promises immediate results, the free plan may not support that promise even though daily usage is small.

Measure peak demand separately from monthly totals. A classroom demonstration, internal launch or shared meeting can create a brief burst that never appears in an average requests-per-day calculation. Use the actual project limits and request distribution to choose a concurrency cap.

Stored documents become many chunks

For a hypothetical retrieval prototype with 500 documents and an average of 20 chunks per document, the index contains 10,000 chunks. At 1,024 float32 dimensions, raw vectors alone occupy 10,000 × 1,024 × 4 = 40,960,000 bytes, or 40.96 decimal MB. Text, metadata and database indexes add overhead.

This calculation helps compare configurations; it does not establish that a specific free database will accept the workload. Check collection, namespace, tenant and indexing constraints as well as storage. If the application needs separate data boundaries for many customers, a tenant limit can bind before memory does.

Plan for updates and deletion. A prototype that appends a new copy of every changed document can fill its allowance much faster than one that replaces old chunks. Keep stable document IDs and a way to remove stale records so search results do not mix current and obsolete information.

A 500-request pilot and its paid exit cost

Assume 100 pilot users each make five requests. That produces 500 requests. At 1,000 input and 200 output tokens per request, the pilot uses 500,000 input tokens and 100,000 output tokens. This is a workload assumption you should replace with measured usage.

At Gemini 2.5 Flash's listed standard text rates of $0.30 input and $2.50 output per million tokens, the same usage would cost $0.15 + $0.25 = $0.40 in model tokens. This excludes tools, storage, retries and other services. The example shows why a small paid prototype can sometimes be easier to budget than a complex effort to remain within a free allowance.

If traffic grows one hundredfold with the same request shape, that model-token calculation becomes $40. Growth may also change request length, concurrency and support requirements, so do not extrapolate only the request count. Save actual usage distributions as the pilot develops.

Set an exit condition before starting: a certain number of evaluated tasks, a particular quality threshold or a known quota constraint. The free phase should answer whether the feature is useful. It should not become an indefinite project to work around limits while avoiding a small, understood operating cost.

Which free tier fits your prototype?

A personal document-search experiment

Start with a small corpus you are authorized to use and a model/data tier appropriate for it. A free database plus a bounded embedding and generation budget can test retrieval quality. Write a set of questions with known evidence passages so you can identify whether failures come from chunking, retrieval or generation.

Do not upload a large archive before checking the first few documents. Confirm that text extraction preserves headings, tables and identifiers. A larger free storage allowance is not useful if the preprocessing strips out the facts the user needs.

A public chatbot demonstration

Focus on request limits and abuse controls. Give each visitor a bounded interaction, limit input size and cap work per request. A free API key behind an unrestricted public endpoint can exhaust its allowance quickly, even when the model works correctly.

Define a graceful stopped state. Tell the user when capacity is exhausted and preserve any action they need to retry. Avoid silently switching to an untested provider or presenting an incomplete answer as success. A demonstration can be useful with a clear capacity limit.

A batch classification project

Estimate record count, input size and the number of model calls per record. If the work can wait, queue it within the permitted throughput rather than sending a burst. Save completed records so a restart resumes from the last verified result.

Validate labels on a representative sample before processing the whole collection. A free run that produces unusable labels costs time and may require reprocessing. The first objective is a reliable classification rule; maximizing free throughput comes afterward.

A team coding-tool evaluation

Use the same starting revision and tasks for each candidate. Check whether free access is individual-only and whether organization policies permit the trial. Keep private repository permissions within the team's approved process.

Record accepted changes, failed tests and manual corrections. If a tool reaches its quota, record the task and usage state rather than repeatedly creating accounts. The decision is whether the product is worth adopting under its actual terms.

A product handling confidential documents

Begin with data requirements. Determine which content may leave your environment, which provider terms apply and who owns retention decisions. Use synthetic or approved non-sensitive examples until that review is complete.

A free tier with unsuitable data terms is not a usable saving for this project. Consider a paid tier with appropriate terms or an approved local deployment. Evaluate the full data path, including logs, storage and connected tools, rather than only the model endpoint.

Build an allowance worksheet for the whole prototype

A useful free-tier comparison follows one complete user action from input to result. For a document-search application, the initial upload may trigger extraction, chunking, embeddings and database writes. A later question may trigger a query embedding, a search, reranking and answer generation. Free access to one component does not cover the others automatically.

Worksheet fieldWhat to write downWhy it matters
Service and exact planProvider, model or database, account and plan nameA similarly named consumer product may have different allowances.
Free unitCalls, tokens, objects, storage, compute time or monetary creditsThese units cannot be compared by their numeric value alone.
Reset or expiryDaily/monthly reset, one-time expiry, or ongoing capacity capA fresh monthly allowance does not necessarily renew trial credits.
ScopeAccount, organization, project, endpoint or modelSeveral users may consume the same allowance.
Exhaustion behaviorRequest rejected, work queued, service paused or paid usage enabledThe application needs to handle the actual outcome.
Paid exitUnit rates, minimum spend and optional servicesA small prototype may move to a plan with a minimum charge.
Export and deletionHow to preserve source data and remove temporary resourcesThe experiment should remain recoverable when the offer changes.

Mark unverified fields as unknown instead of assuming the most generous interpretation. If your account shows a promotional credit, record its amount and expiry privately in the project budget. Do not publish an account-specific offer as a benefit every reader will receive.

A call allowance is smaller than a search allowance

Take a hypothetical prototype with a pool of 1,000 evaluation calls. Suppose every search uses one embedding call, one reranking call and one generation call, all counted against that pool. With no other activity, the maximum is 333 complete three-call searches, with one call left over: floor(1,000 / 3). If setup and evaluation already used 100 calls, the remaining 900 support at most 300 such searches.

This is arithmetic for an explicitly shared allowance, not a statement that every provider combines endpoints in this way. Check which calls count and whether batch inputs consume the same unit. A provider may meter input items, tokens or endpoint-specific operations differently. Keep the calculation beside the documented definition of a call.

Now reserve 60 of those remaining calls for retries and debugging. The planned user capacity becomes floor((900 − 60) / 3) = 280 searches. That reserve is an illustrative planning choice, not a universal recommended percentage. The right reserve depends on observed failures and how much unfinished work the demonstration can tolerate.

If the embedding model is also used during ingestion, budget those calls before announcing the user capacity. A prototype can consume most of its allowance loading a corpus even before its first search. Reusing unchanged embeddings and resuming completed ingestion work can reduce repeated work; changing the embedding model may require a new index.

Design the state users see when capacity runs out

Choose the behavior before opening a prototype to other people. A classroom demonstration might stop accepting new requests and explain when it can resume. An internal batch tool might retain pending records for the next permitted processing window. A public feature may need an explicitly budgeted paid tier before launch. These are different product decisions.

Preserve the user's input and distinguish pending work from a completed result. If generation stops after retrieval, show that the answer is incomplete rather than presenting a fragment as final. Keep a stable task identifier so a retry can resume or safely rerun the intended operation without duplicating an upload or other side effect.

A quota reset should not be implemented as an immediate release of every queued job. Use the service's actual throughput limits and a bounded queue. Otherwise a day-long backlog can exhaust the new allowance within moments and leave the same users waiting again.

Test this behavior with a controlled low application limit during development. You do not need to deliberately exhaust a provider account to learn whether your UI handles a capacity error. Verify that the application communicates the state, preserves work and avoids an uncontrolled retry loop.

Questions that change the free-tier decision

Does a free account mean the API is free?

No. Account creation, reading model cards, chatting in a consumer interface and running an inference API are separate activities. Hugging Face's current billing table is a concrete example: a free account does not include monthly Inference Providers credits. Establish the allowance for the exact API route before writing it into a budget.

Does a paid chat subscription cover my application?

Only where the provider explicitly supports the authentication and usage route you intend to use. A plan-linked integration can have its own eligibility and permission requirements. It does not make a separately created backend API key free, and it does not automatically let an application consume another person's allowance.

Is a trial enough for production?

A trial can answer a bounded technical question. Production adds requirements such as sustained capacity, support, access management, data handling and recovery. Check those requirements against the exact offer. Do not assume that successful test requests establish permission or capacity for an ongoing customer-facing service.

Should I switch providers to stay free?

Compare the expected saving with migration and evaluation effort. If the paid continuation of your measured pilot costs less than the engineering time required to change endpoints, staying may be the practical option. A switch can still make sense for quality, access or data requirements; those reasons should be stated independently of the free allowance.

When is a local model the better experiment?

Consider it when local data handling, offline operation or deployment control is part of the question you need to test. Record hardware, runtime, model revision and memory requirements. A local model avoids a hosted API bill only for the work kept local; a connected reranker, embedding service or fallback API may still charge separately.

A practical free-tier evaluation plan

Start by writing the question the prototype must answer. “Can users find the correct policy paragraph?” is testable. “Can we build an AI product for free?” combines retrieval quality, interface work, operating costs and commercial viability into one question. A free allowance is more useful when it supports a bounded experiment with a result you can interpret.

Choose representative inputs before opening provider accounts. For document search, include short files, long files, duplicate versions and a question whose answer is absent. For classification, include an ambiguous example and a category outside the expected list. For a coding tool, use a task in the repository you intend to maintain. Avoid using only the provider's demonstration prompts: they do not establish that your own workload fits the offer.

Record a small baseline using the existing manual process or a simpler implementation. Measure completion and review effort rather than assigning a score because the generated answer sounds polished. If a free model returns a plausible but incorrect policy answer, that is a failed task even though the request stayed inside the allowance. Keep the expected answer and supporting document beside the output.

Run ingestion and user queries as separate stages. Save the number of documents accepted, chunks created, embedding requests, stored objects and rejected inputs. Then run the saved questions and count generation and reranking activity. This separation shows whether a storage cap, an ingestion allowance or a request-rate limit will constrain the next experiment.

End the trial with a decision: continue on the same plan, pay for a named requirement, change a component, or stop. Preserve the evaluation inputs and results so that a provider change does not erase what you learned. A trial is complete when it answers its question, even if it leaves credits unused.

Storage, deletion and portability before the free plan ends

A storage allowance measures capacity, not necessarily the amount of original material you can keep. A source document can produce multiple chunks, vectors, metadata records and a separate original-file copy. Include those objects in the design. If the application keeps both an old and a replacement index during migration, budget for that overlap before starting the rebuild.

Keep a copy of the source documents and stable identifiers outside the vector database when your data-handling requirements permit it. Store the embedding model name and version with the ingestion configuration. That makes it possible to recreate an index if the trial expires or the offer changes. An exported vector alone may not preserve the source passage, permissions or metadata needed to serve a useful answer.

Check deletion separately from export. Deleting a collection, deleting an uploaded source file, removing an application log and closing an account can be different operations. Read the service's current retention documentation for the data you submit; do not infer that an empty application screen proves every retained copy has been removed. Use non-sensitive fixtures until the data requirements are resolved.

Before moving to a paid tier, identify which settings or resources transfer with the upgrade. A new paid project may require a fresh deployment, credentials or index import rather than an in-place capacity increase. Keep that migration work in the pilot plan. The useful cost comparison includes both the first paid month's service bill and the effort required to continue the experiment.

What to save in the final prototype record

Save the exact offer and check date, the endpoint used, the allowance unit, the consumed quantities and the unresolved limits. Attach the test inputs, expected outputs, failure examples and a small paid-continuation calculation. Record the project owner and a cleanup date for resources that are no longer needed. This gives the next developer enough information to reproduce the result without treating an expired promotional offer as a permanent product capability.

When to upgrade or change providers

Upgrade when the pilot demonstrates useful behavior and a specific plan limitation blocks the next valid use: throughput, storage, collaboration, support or a required operational feature. A paid plan should solve a named problem. Reaching an arbitrary percentage of storage is not by itself a reason to buy.

Change providers when the current route cannot meet a requirement at an acceptable cost, and a tested alternative can. Preserve evaluation cases, prompts and data exports before migrating. A different free allowance does not compensate for poor task quality or an expensive rewrite.

Keep a record of the offer date, plan name, allowance, reset behavior and paid rate. Recheck it before a public launch or procurement decision. Free plans and trials change; an old update-history paragraph is not a substitute for the current provider documentation.

Choose the prototype's bottleneck first, then select the offer that lets you test it. Use the Gemini guide and ChatGPT guide for product-specific questions, and the API pricing comparison for sustained operation. PE Collective is responsible for the next factual review when an included offer changes.

Illustrated portrait of Rome Thorndike

Rome Thorndike

Rome Thorndike is the CEO & Founder of Provyx, which provides GTM intelligence and data validation for healthcare companies, including EngagedMD and BTL Industries. He writes The AI News Digest for over 3,000 subscribers and has worked in Azure AI/ML enterprise sales and AI-company customer delivery.

Connect on LinkedIn