There's a version of this post that lists four providers, pastes their pricing page, and calls it a comparison. This isn't that. I've spent time actually building with each of these APIs Gemini in a production Next.js project, GPT-4o in the OCR pipeline I wrote about previously, Claude for document extraction, and Grok for a few lower-stakes automation tasks. So when I talk about what these free tiers actually get you, I'm talking about what happens when you try to build something real inside them.
The state of free AI API access is genuinely better than it was a year ago but also more uneven than the headlines suggest. Google is the only provider with a truly permanent free tier for API access. Everyone else is offering credits, trial periods, or conditional programs. Knowing this before you architect anything is the difference between building something sustainable and running into a wall at the worst possible time.
The Quick Overview All Four Providers at a Glance
Google Gemini The Most Generous Free Tier, With One Catch
If you need ongoing free API access with no expiry date and no credit card, Gemini via Google AI Studio is the answer. As of mid-2026, Gemini 2.5 Flash gives you 10 RPM and 500 requests per day on the free tier. Gemini 2.5 Flash-Lite goes even further 15 RPM and 1,000 requests per day. The token-per-minute limit is 250,000 across all free models, which you'll hit your RPM cap long before you approach.
There was a significant quota reduction in December 2025 that caught a lot of developers off-guard. If you're reading older tutorials that mention 15 RPM for Flash, those numbers pre-date the cut. Work with the current figures.
The catch that matters: on the free tier, Google may use your prompts and responses to improve their models. This is in their terms. For hobby projects, tutorials, and public data fine. For anything involving client data, proprietary content, or anything sensitive upgrade to the paid tier before you start sending it. The paid Tier 1 is still cheap and removes the data-sharing clause entirely.
// Gemini API in C# using HttpClient directly (no SDK required)
using System.Net.Http;
using System.Text;
using System.Text.Json;
var geminiKey = Environment.GetEnvironmentVariable("GEMINI_API_KEY")
?? throw new InvalidOperationException("GEMINI_API_KEY not set");
using var client = new HttpClient();
// Gemini uses the key as a query parameter, not a header
var endpoint = $"https://generativelanguage.googleapis.com/v1beta/models/" +
$"gemini-2.5-flash:generateContent?key={geminiKey}";
var payload = new
{
contents = new[]
{
new
{
parts = new[] { new { text = "Summarise the benefits of prompt caching in one paragraph." } }
}
},
generationConfig = new
{
temperature = 0.1,
maxOutputTokens = 512
}
};
var json = JsonSerializer.Serialize(payload);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PostAsync(endpoint, content);
response.EnsureSuccessStatusCode();
var result = await response.Content.ReadAsStringAsync();
using var doc = JsonDocument.Parse(result);
var text = doc.RootElement
.GetProperty("candidates")[0]
.GetProperty("content")
.GetProperty("parts")[0]
.GetProperty("text")
.GetString();
Console.WriteLine(text);
// Get your free API key at: https://aistudio.google.com/app/apikey
// No credit card required key activates immediatelyAnthropic Claude Small Budget, High Quality
Claude's free offering is smaller than Gemini's but the quality ceiling is higher. The ~$5 in trial credits you get at console.anthropic.com (no card needed) go furthest on Haiku 4.5, which is fast, cheap, and handles most common tasks well. Sonnet 4.6 is where you'll want to test for anything requiring reasoning or complex output structure.
What Claude does noticeably better in my testing: complex layout handling in document extraction, nuanced multi-step instructions, and consistent JSON output structure. For the kinds of .NET tasks I write about invoice parsing, structured data extraction, content pipelines it's the model I reach for when accuracy on edge cases matters more than raw throughput.
One important note: there is no permanent free API tier after the trial credits are used. Once they're gone, you add a payment method. The minimum deposit to unlock Tier 1 is $5, and from there it's pure pay-per-use with no monthly minimum.
// Claude API in C# HttpClient approach
using System.Net.Http;
using System.Text;
using System.Text.Json;
var claudeKey = Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY")
?? throw new InvalidOperationException("ANTHROPIC_API_KEY not set");
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("x-api-key", claudeKey);
client.DefaultRequestHeaders.Add("anthropic-version", "2023-06-01");
var payload = new
{
model = "claude-haiku-4-5-20251001", // Haiku most cost-effective on free credits
max_tokens = 512,
messages = new[]
{
new { role = "user", content = "Extract the invoice number and total from this text: INV-2041, Total: $4,200.00" }
}
};
var json = JsonSerializer.Serialize(payload);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PostAsync("https://api.anthropic.com/v1/messages", content);
response.EnsureSuccessStatusCode();
var result = await response.Content.ReadAsStringAsync();
using var doc = JsonDocument.Parse(result);
var text = doc.RootElement
.GetProperty("content")[0]
.GetProperty("text")
.GetString();
Console.WriteLine(text);
// Track token usage key for staying within free credits
var usage = doc.RootElement.GetProperty("usage");
Console.WriteLine($"Tokens used Input: {usage.GetProperty("input_tokens")}, Output: {usage.GetProperty("output_tokens")}");OpenAI GPT-4o Familiar, But the Free Window Is Short
OpenAI gives new API accounts $5 in trial credits same as Anthropic but with a hard 3-month expiry. If you don't use them within 90 days of account creation, they're gone. That's a meaningful difference if you're planning a project over time rather than sprinting straight into it. The credits work across all models including GPT-4o, GPT-4.1, o3, and the mini/nano variants.
GPT-4o-mini is worth calling out specifically: on the free tier it runs at up to 500 RPM significantly higher than Claude or Gemini Flash. If your use case involves many small, fast requests rather than fewer complex ones, this rate limit advantage matters. On the other hand, there's no equivalent to Gemini's permanent free tier here once your $5 is gone, you're paying.
// OpenAI GPT-4o in C# using the official Azure.AI.OpenAI SDK
// dotnet add package Azure.AI.OpenAI
using Azure.AI.OpenAI;
using OpenAI.Chat;
var openAiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY")
?? throw new InvalidOperationException("OPENAI_API_KEY not set");
var aiClient = new AzureOpenAIClient(new Uri("https://api.openai.com/v1"), new ApiKeyCredential(openAiKey));
var chatClient = aiClient.GetChatClient("gpt-4o-mini"); // mini same free tier, much cheaper
var messages = new ChatMessage[]
{
ChatMessage.CreateSystemMessage("You are a precise data extractor. Return JSON only, no markdown."),
ChatMessage.CreateUserMessage("Extract: vendor name and total from 'ACME Corp Invoice #441 Total: $1,850'")
};
var completionOptions = new ChatCompletionOptions { Temperature = 0.1f };
var completion = await chatClient.CompleteChatAsync(messages, completionOptions);
var output = completion.Value.Content[0].Text;
Console.WriteLine(output);
Console.WriteLine($"Tokens Input: {completion.Value.Usage.InputTokenCount}, Output: {completion.Value.Usage.OutputTokenCount}");xAI Grok The Biggest Credit Upfront, With Some Caveats
Grok is the most interesting free tier story of 2026 and also the least predictable. New xAI Console accounts get $25 in signup credits, and there's a data-sharing program that offers up to $150/month in ongoing credits if you opt in. On paper, that's more free access than anyone else. In practice, verify what's currently available in the xAI Console before building on it the data-sharing program has been subject to changes and the terms around it have shifted since launch.
The pricing on Grok is genuinely competitive when you move past the free tier: Grok 4.1 Fast runs at $0.20/$0.50 per million tokens, which undercuts most providers significantly. The API is OpenAI-compatible, meaning you only need to change the base URL and model name to switch no rewrite required. That's a real convenience advantage for developers who already have OpenAI SDK integrations.
// Grok API in C# OpenAI-compatible, so the same SDK just works
// dotnet add package Azure.AI.OpenAI
using Azure.AI.OpenAI;
using OpenAI.Chat;
var grokKey = Environment.GetEnvironmentVariable("XAI_API_KEY")
?? throw new InvalidOperationException("XAI_API_KEY not set");
// Only two things change from OpenAI: the base URL and the model name
var grokClient = new AzureOpenAIClient(new Uri("https://api.x.ai/v1"), new ApiKeyCredential(grokKey));
var chatClient = grokClient.GetChatClient("grok-4.1-fast"); // cheapest production Grok model
var messages = new ChatMessage[]
{
ChatMessage.CreateUserMessage("What are the key benefits of the OpenAI-compatible API format?")
};
var completion = await chatClient.CompleteChatAsync(messages);
Console.WriteLine(completion.Value.Content[0].Text);
// Switching from OpenAI to Grok in an existing project:
// 1. Change base URL to https://api.x.ai/v1
// 2. Change model name (gpt-4o → grok-4.1-fast)
// 3. Swap API key env variable
// That's it everything else is identicalWhich One Should You Actually Start With?
Stacking Credits Getting the Most Before You Pay Anything
Here's something most posts don't mention: you can use all four providers simultaneously and stack their free credits during evaluation. Nothing stops you from signing up for all four, running your test workload across each, and comparing results before you commit to any one provider. The total free budget across providers is roughly:
Gemini: permanent 500 RPD (keeps running indefinitely)
Claude: ~$5 (no expiry but used when consumed)
OpenAI: ~$5 (expires in 3 months)
Grok: ~$25 signup (program-dependent for ongoing)
For a typical extraction or chatbot evaluation run a representative sample of 100–200 documents through each. Compare accuracy, latency, and output consistency. The provider that works best for your specific documents and use case is the right answer, not the one with the biggest marketing budget. Your actual data will tell you things that no benchmark article (including this one) can.
My Honest Take After Using All Four
If I had to pick one provider to start with for a .NET developer building something document-related which is most of the readers of this blog it'd be Claude for the initial evaluation and Gemini for sustained free development once you've confirmed what you need. Use the Claude credits to understand the quality ceiling. Use Gemini's permanent free tier to build and iterate without watching a credit counter.
GPT-4o is a solid choice if you're already in the OpenAI ecosystem or your use case specifically benefits from the higher rate limits on the mini model. Don't default to it just because it's the most familiar name in the room the evaluation process exists precisely so you don't have to.
And Grok is worth the 15 minutes it takes to sign up and run a smoke test, especially if the data-sharing credits are still active when you're reading this. At $0.20/M input tokens on 4.1 Fast, the cost structure at scale is genuinely different from the others worth knowing before you lock into a provider for a production system.
Have Thoughts? Let's Talk.
If you've run a real evaluation across these providers, have production numbers that tell a different story, or found the free tier limits different from what's in this post that's exactly the kind of information I'd want to know about. Hit the link below.
💬 Start a Discussion →
Opens your email client with my address pre-filled. No tracking, no funnel just a real conversation.
