DEV Community: toolfreebie

groq/llama-3.3-70b-versatile is not on Groq's model list anymore

toolfreebie — Mon, 24 Aug 2026 14:10:27 +0000

Groq's model lineup rotated — the current chat models are gpt-oss-120b, gpt-oss-20b and qwen3.6-27b, and the Llama-era IDs that every LiteLLM tutorial hardcodes are no longer in the catalog. You can check what your key actually has with one call:

curl -s https://api.groq.com/openai/v1/models -H "Authorization: Bearer $GROQ_API_KEY"

If you call the old ID directly, you at least get a loud error. The sneaky case is a LiteLLM fallback chain. The whole point of fallbacks is to absorb failures — so when the first entry in the chain is a dead model ID, every single request fails over to your second choice, silently. Nothing crashes. Your app keeps answering. You just quietly lose the provider you picked for speed, eat an extra failed round-trip of latency on every call, and shift 100% of traffic onto the fallback (and its rate limits) without a word in your logs unless you look for it.

Worth two minutes today: grep your configs for llama-3.3-70b-versatile and mixtral-8x7b-32768, swap in a model ID from the live catalog, and if you run fallback chains, alert on fallback-hit rate — it is the only place this class of rot shows up.

How the LiteLLM free-tier setup fits together: https://toolfreebie.com/litellm-free-llm-gateway/

Neon's free plan is 100 small projects now, not one database

toolfreebie — Mon, 24 Aug 2026 13:27:32 +0000

If your mental model of Neon's free tier is "one project, ~190 compute hours, 10 branches", that shape is gone. The pricing page now lists the free plan as: up to 100 projects, each with 100 compute-unit-hours per month and 0.5 GB of storage, compute sizes up to 2 CU (8 GB RAM), no credit card.

Two consequences fall out of that, one nice and one that will bite somebody.

The nice one: per-tenant and per-PR databases stopped being a paid-plan feature. A hundred isolated projects at 0.5 GB each is a lot of preview environments, staging copies, and one-database-per-customer experiments for $0.

The one that bites: a single always-on database no longer fits. The smallest compute is 0.25 CU, and a 30-day month is 720 hours — keeping one database awake around the clock costs about 180 CU-hours, against an allowance of 100 per project. Scale-to-zero is doing the real work in that budget: the allowance only drains while the database is awake, so a hobby app with idle nights is fine, but anything that pins the compute awake (an aggressive connection pool, a cron that fires every few minutes, an uptime monitor pinging your API which queries the db) will run a project dry partway through the month.

So the free plan got better for the many-small-databases pattern and quietly stopped covering the one-database-that-never-sleeps pattern. Which side of that line you're on is worth knowing before the end-of-month surprise.

Side-by-side of Neon against Supabase's free Postgres: https://toolfreebie.com/supabase-vs-neon/

Groq's 14,400 requests a day is not for the chat models

toolfreebie — Mon, 24 Aug 2026 12:14:48 +0000

If you have sized a project against Groq's free tier recently, the number you probably wrote down was 14,400 requests per day. It appears in a lot of comparison posts. It is on Groq's own rate limits page too, which is why it keeps propagating.

It just isn't attached to a model you would chat with.

Groq's Free Plan limits are published per model. As of today the chat models sit at 30 RPM and 1,000 RPD: openai/gpt-oss-120b, openai/gpt-oss-20b, and qwen/qwen3.6-27b all get 30 requests per minute, 1,000 per day, 8K tokens per minute, 200K per day. groq/compound is lower still at 250 RPD.

The two rows carrying 14.4K RPD are meta-llama/llama-prompt-guard-2-22m and meta-llama/llama-prompt-guard-2-86m. Those are 22M and 86M parameter classifiers whose job is screening prompts for injection attempts. They are meant to be called on every inbound message, which is exactly why their ceiling is high. They do not generate text.

So the practical gap is about 14x. If you planned an agent loop assuming 14,400 generations a day on the free plan, the real budget is 1,000, and you will find out when the 429s start.

Worth checking your own console rather than trusting any table, including this one, since these move without announcement. The rate limits page shows a Free Plan tab and a Developer plan tab, and the per-model rows are the only figures that mean anything.

Fuller comparison of the three fast free APIs: https://toolfreebie.com/groq-vs-cerebras-vs-gemini/

Marker and Surya are Apache 2.0 — their model weights are not

toolfreebie — Mon, 24 Aug 2026 06:02:22 +0000

If you pick an OCR library by glancing at the license badge on its GitHub page, these two will catch you out.

Marker and Surya (both from Datalab) show Apache-2.0 in GitHub's sidebar, and that is accurate — for the code. The model weights are under a separate licence: a modified AI Pubs Open Rail-M, free for research, personal use, and startups under $5M in funding or revenue. Past that line you need a commercial licence from Datalab. Both projects say so plainly in a "Commercial usage" section of their README; it just isn't what the badge reports, and the badge is what most roundups copy.

The distinction matters because the badge is doing the opposite of its job here. Apache 2.0 on the repo tells you that you may use, modify and redistribute the code. It says nothing about your right to run the weights in a product — and without the weights the code does not do OCR.

One thing worth flagging if you are reading older comparisons: Marker used to be GPL-3.0 with a $2M cap. It has since relicensed the code to Apache 2.0 and both projects now sit at $5M. So a post from six months ago can be wrong in your favour or against it, in either direction. Check the README and the LICENSE file, not a table someone else compiled.

If you need something with no revenue test at all, Docling is MIT, and Tesseract, olmOCR, PaddleOCR and RapidOCR are all Apache 2.0 end to end.

Fuller comparison of the OCR options, hosted and self-hosted: https://toolfreebie.com/free-ocr-api-pdf/

Koyeb's Starter plan: closed to new signups, kept for existing orgs

toolfreebie — Mon, 24 Aug 2026 04:02:28 +0000

Two things are true about Koyeb at the same time right now, and the mix confuses people who are trying to work out whether they still have a free instance.

Mistral AI announced it was acquiring Koyeb on February 17, 2026. Koyeb's FAQ now says the Starter plan will soon be removed and that new users will need to subscribe to Pro, Scale, or Enterprise instead. The pricing page matches: the cheapest plan on offer is Pro at $29/month, with $10 of included compute. There is no free plan listed for anyone signing up today.

But the same FAQ says existing organizations on that plan keep their current terms. So if your org was already on Starter, your free instance is still running — 512MB RAM, 0.1 vCPU, 2GB SSD — and nothing has changed for you yet.

That "yet" is the part worth planning around. The wording is "soon" and "in the coming months." No date has been published for when grandfathered free instances stop. If you have one, it is not a thing to build a long-term dependency on, and it is worth exporting anything you would miss.

Worth knowing if you are reading older write-ups: a lot of them still describe Koyeb's free Hobby tier as though you can go sign up for it. You can't. The instance sizes still appear in Koyeb's public instance catalog, which is probably why the stale posts look plausible.

I keep the current state of it, plus what is still genuinely always-on, written up here: https://toolfreebie.com/koyeb-free-tier-alternatives/

Railway's Free plan costs $1 a month

toolfreebie — Mon, 24 Aug 2026 03:21:53 +0000

Railway's pricing page lists four plans, and the first one is headlined Free — $0 per month. Read the line directly underneath it:

Start with a 30-day free trial with $5 credits, then $1 per month

So the plan named Free is $0 for thirty days and a dollar a month after that. It also caps each service at 1 vCPU and 0.5 GB of RAM, with 0.5 GB of volume storage.

A dollar is not a lot of money. That isn't the point. The point is that "free tier" round-ups keep sorting Railway into the free column on the strength of the plan's name, and anyone building a comparison — or picking a host precisely because they want a zero-dollar bill and no payment relationship — is working from a wrong premise.

What makes this one easy to get wrong is that the internet currently holds two stale versions of Railway at once. Articles written before the change say Railway killed its free tier in 2025 and offers only a one-time $5 trial credit, which is no longer true. Articles written after it say Railway has a free plan again, which is true in name and misleading in substance. Both are confidently wrong in opposite directions.

Worth checking the actual pricing page rather than trusting either.

Current Railway numbers and how the plans compare: https://toolfreebie.com/railway-heroku-alternative/

A daily cron ping won't stop Oracle reclaiming your idle instance

toolfreebie — Mon, 24 Aug 2026 03:04:42 +0000

The advice you see everywhere for keeping an Oracle Always Free instance alive is to point a cron job at it — hit it once a day and it counts as activity. I went and read Oracle's own Always Free documentation, and that isn't how the rule works.

Oracle deems a compute instance idle only if, across a 7-day period, all three of these are true at once:

CPU utilization at the 95th percentile is below 20%
network utilization is below 20%
memory utilization is below 20% — this one applies to A1 shapes only

A once-a-day HTTP request does essentially nothing to a 95th-percentile CPU figure. That statistic asks what your CPU was doing during the busiest 5% of the window, and a handful of requests spread across seven days doesn't register. So the ping trick can leave you fully inside the idle definition while feeling like you've solved it.

The useful half of the rule is the word all. Because every condition has to hold for the instance to count as idle, clearing any single one keeps you out. On a 12 GB A1 the memory threshold is usually the easiest to stay above without trying: anything genuinely resident — a Docker stack, a database, a password manager — holds memory above 20% continuously, no cron job required.

So the honest version is that you don't keep the box by pinging it. You keep it by actually running something on it.

Full current Always Free numbers, including what the June 2026 halving changed: https://toolfreebie.com/oracle-free-arm-vps/

Render's free tier doesn't cover background workers

toolfreebie — Mon, 24 Aug 2026 01:03:02 +0000

If you're sizing a small Python app for Render's free tier — a web service in front, and a worker process that has to stay up to drain a queue — the worker half of that doesn't work. The pricing page doesn't make it obvious why, so here is what it actually says.

Render's free compute is real, but it doesn't apply to every service type. Their pricing FAQ is specific about which ones: free compute plans let you spin up web services, Render Key Value instances, and Render Postgres databases at no charge. Background workers aren't on that list. And on Render a worker is its own service type — not a web service you happen to run a loop inside. The cheapest instance you can attach to one is Starter, at $7/month.

So what you actually get for $0 is a web service that sleeps after 15 minutes idle, a Key Value instance, and a Postgres database that expires after 30 days. That's fine for a demo. It is not a setup for anything that has to keep working while nobody is looking at it.

The failure mode is the part worth knowing in advance. The obvious workaround is to move the queue loop inside the free web service — but that service spins down once traffic stops, and your queue quietly stops draining. No error, no crash, nothing in the logs. It just looks like there was nothing in the queue.

If you're mapping out which free tiers still include what, I keep that written up here: https://toolfreebie.com/best-free-hosting-2026/

GLM Free API: Zhipu’s Flash Models at Zero Cost

toolfreebie — Thu, 20 Aug 2026 07:15:05 +0000

Quick answer: The GLM API from Zhipu AI, served internationally via Z.ai, keeps three models permanently free ($0 in / $0 out, no credit card) — including GLM-4.7-Flash with a ~200K-token context tuned for coding and agents. It exposes both OpenAI-compatible and Anthropic-compatible endpoints, so you can point Claude Code, Cline, or Aider at it with a two-variable swap. The only real limit is throughput: one concurrent request, ~1/second.

If you build with LLMs you’ve probably collected free keys — Gemini, Groq, DeepSeek, OpenRouter. The one most developers outside China miss is GLM from Zhipu AI (a Tsinghua spin-out, current flagship GLM-5.2). What makes it worth wiring in: genuinely free models (not expiring trial credits), a free ~200K coding context, and an Anthropic-compatible endpoint nobody else on this list matches. Every number below comes from Z.ai’s own pricing docs — confirm there before you build.

Is the GLM API free? The honest breakdown

Yes, and it survives scrutiny: Z.ai keeps a set of models at $0 input / $0 output for every registered user — a standing free tier, not trial credits. The trade-off is throughput, not access. The three permanently free models:

Model	Type	Context	Price	Best for
GLM-4.7-Flash	Text / coding	~200K tokens	$0 / $0	Coding, agents, long documents
GLM-4.5-Flash	Text (general)	128K tokens	$0 / $0	Chat, classification, extraction
GLM-4.6V-Flash	Vision	Multimodal	$0 / $0	Image understanding, OCR, VQA

The headline is GLM-4.7-Flash (released Jan 19, 2026): a ~200,000-token window on a free model is rare — enough to stuff an entire codebase or long PDF into one call — and it’s tuned for coding and agentic loops, not throwaway chat (max 16,384 output tokens). GLM-4.5-Flash is the lighter, low-latency default for high-volume simple jobs (classification, extraction, JSON). GLM-4.6V-Flash fills the rarer slot of a genuinely free vision model sharing the same key. The one caveat: the free tier is throttled to 1 concurrent request, ~1/second — fine for a single-user tool or sequential batch job, not for a public app with many simultaneous users.

Free vs paid: what scaling up costs

GLM’s paid pricing is among the most aggressive in the industry, and the ladder is smooth. Per-million-token rates from the pricing docs:

Model	Input / 1M	Output / 1M	Notes
GLM-4.7-Flash	$0	$0	Free tier, 1 concurrency
GLM-4.5-Flash	$0	$0	Free tier, general-purpose
GLM-4.7-FlashX	$0.07	$0.40	Same Flash quality, ~3 concurrency
GLM-4.5-Air	$0.20	$1.10	Mid-tier balance
GLM-5	$1.00	$3.20	Previous flagship
GLM-5.2	$1.40	$4.40	Current flagship

The clever part is GLM-4.7-FlashX: the same Flash model with the concurrency cap lifted for $0.07/1M input — you graduate a free prototype to production by changing one model string, no rewrite. And at $1.40 / $4.40, flagship GLM-5.2 runs roughly a fifth to a tenth the price of comparable Western frontier models, which is why it shows up in cost-conscious agent stacks. For the wider landscape, the 10 best free AI APIs comparison puts GLM next to Gemini, Groq, and the rest.

Get a key and make your first call

Sign up at z.ai (email or Google/GitHub — no card for free models), generate a key in the API Keys dashboard, and export it. Z.ai exposes an OpenAI-compatible endpoint at https://api.z.ai/api/paas/v4, so the official openai library works unchanged — swap base URL and model name:

from openai import OpenAI

client = OpenAI(
    api_key="your-z-ai-api-key",
    base_url="https://api.z.ai/api/paas/v4",
)
resp = client.chat.completions.create(
    model="glm-4.7-flash",          # the free coding model
    messages=[{"role": "user", "content": "Reverse a linked list in Python."}],
)
print(resp.choices[0].message.content)

curl https://api.z.ai/api/paas/v4/chat/completions \
  -H "Authorization: Bearer $ZAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "glm-4.7-flash", "messages": [{"role": "user", "content": "Say hello."}]}'

Because it’s OpenAI-shaped, streaming, tool calling, JSON mode, and system prompts work with the parameters you already know — point CrewAI, LangGraph, or any “OpenAI” provider at that base URL. To route multiple providers, drop it behind LiteLLM.

The killer feature: GLM as a free Claude Code backend

Z.ai also ships a genuine Anthropic-compatible endpoint at https://api.z.ai/api/anthropic — a true drop-in for Anthropic’s API. That means you can point Claude Code at GLM with zero code changes, using the same env vars the tool already reads:

export ANTHROPIC_BASE_URL="https://api.z.ai/api/anthropic"
export ANTHROPIC_AUTH_TOKEN="your-z-ai-api-key"
claude   # now talks to GLM instead of Anthropic

The reason this gets attention in 2026 is arithmetic: GLM is strong at agentic coding, and running an agent that burns millions of tokens against a $0.07-per-million (or free, at Flash throughput) backend costs a fraction of a frontier-model bill. The same trick works for any tool reading the standard Anthropic env vars. Two honest notes: on the free Flash tier, single-concurrency means the agent runs one request at a time (fine solo, slow if you expected parallelism); and self-hosted runners can register Z.ai as a provider directly (see the OpenClaw provider docs). For more BYOK agents, see the 5 free AI coding assistants roundup.

The GLM Coding Plan: subscription vs pay-per-token

Z.ai also sells a flat monthly GLM Coding Plan for developers who live inside coding agents — a large usage quota instead of metered tokens, billed quarterly, with access to flagship GLM-5.2. Mid-2026 tiers: Lite ~$10/mo, Pro ~$30/mo, Max ~$80/mo (Q2 promos brought these to ~$27/$81/$216 per quarter). It uses a dedicated endpoint (https://api.z.ai/api/coding/paas/v4) — a detail that trips people up. The decision is simple: prototyping or a personal tool → free Flash models; pushing an agent hard where per-token would sting but a flat $10-30/mo is comfortable → the Coding Plan; serving app traffic that needs concurrency → pay-per-token FlashX.

GLM vs DeepSeek vs the free APIs you already use

	GLM (Z.ai)	DeepSeek	OpenRouter free	Together AI free
Truly free models	3 (incl. 200K coding)	Low-cost, small free trial	Rotating free variants	Handful of “-Free” models
Free context ceiling	~200K (GLM-4.7-Flash)	Varies	Varies	Up to model max
OpenAI-compatible	Yes	Yes	Yes	Yes
Anthropic-compatible	Yes (Claude Code drop-in)	No	No	No
Free vision model	Yes (GLM-4.6V-Flash)	No	Sometimes	Yes (Llama Vision)
Coding/agent focus	Strong (Flash tuned for it)	Strong (R1 reasoning)	Depends on model	General
Free concurrency	1 req/sec	Rate-limited	Shared, variable	Rate-limited

Choose GLM for a free coding/agent model with a huge context, or to run Claude Code / Cline against a cheap backend — the Anthropic endpoint is the differentiator.
Choose DeepSeek for top-tier open reasoning (R1) at rock-bottom pay-as-you-go prices.
Choose OpenRouter to sample many models — including free GLM variants — through one aggregator key.
Choose Together AI for free chat, vision, and image generation (FLUX) behind one key.

In practice these are complements: GLM-4.7-Flash for coding agents, DeepSeek R1 for hard reasoning, Together’s FLUX for images — all routed through LiteLLM so switching is one line.

Limits and honest caveats

Free tier is single-concurrency (~1 req/sec) — generous for a personal tool, inadequate for a multi-user product. Move to FlashX or paid before real traffic; it’s a one-string change.
Two platforms, two accounts. Z.ai (international, English, this article) and the Zhipu Open Platform (open.bigmodel.cn, China, RMB) are separate — a key from one won’t work on the other.
Data residency. GLM is operated by a China-based company with its own data terms. Fine for hobby and non-sensitive code; for regulated or proprietary data, read the terms and consider a self-hosted model or a provider in your jurisdiction. Treat it as a compliance decision.
Free tiers move — confirm model tiers and prices against the live pricing docs before architecting around a limit.

Frequently Asked Questions

Is the GLM API really free?

Yes. Z.ai keeps GLM-4.7-Flash (text/coding, ~200K), GLM-4.5-Flash (general), and GLM-4.6V-Flash (vision) permanently free at $0/$0, no card — a standing free tier, not expiring credits. The only limit is throughput: one concurrent request at ~1/second.

Can I use GLM with Claude Code?

Yes. Set ANTHROPIC_BASE_URL to https://api.z.ai/api/anthropic and ANTHROPIC_AUTH_TOKEN to your Z.ai key, then run Claude Code normally — it sends requests to GLM instead of Anthropic. This is a main reason GLM is popular as a low-cost coding-agent backend.

What’s the difference between GLM-4.7-Flash and FlashX?

Same underlying model quality. Flash is the free tier, capped at single concurrency. FlashX is the paid, higher-throughput version ($0.07/1M in, $0.40/1M out) for serving real traffic. Develop on Flash for free, switch the model string to FlashX for production.

GLM vs DeepSeek — which is better?

Different strengths. GLM offers a genuine free tier with a huge coding context and an Anthropic-compatible endpoint for agents; DeepSeek is renowned for deep R1 reasoning at very low pay-as-you-go prices with a smaller free tier. For free coding agents, GLM; for cheap heavyweight reasoning, DeepSeek. Many developers use both.

Bottom line

The GLM free API is one of the most under-used free keys a developer can add in 2026: three permanently free models — a ~200K coding model, a lightweight general model, and a vision model — with no card, no expiry, and both OpenAI- and Anthropic-compatible endpoints. Driving a coding agent solo? Point Claude Code or Cline at GLM-4.7-Flash free, or the ~$10/mo Coding Plan for all-day use. Need a free model that swallows a whole repo? The ~200K free context is rare at $0. Going to production? Switch one string to FlashX. It’s not the model for regulated data, and single-concurrency makes it shine as a personal and prototyping tool — but as a free, drop-in coding brain, it slots right into the stack you already have.

Appwrite: Free Open-Source Backend (Firebase Alternative)

toolfreebie — Thu, 20 Aug 2026 07:09:35 +0000

Quick answer: Appwrite is an open-source (BSD 3-Clause) backend-as-a-service — auth, database, storage, serverless functions, messaging, realtime, and hosting in one platform. Its Cloud free plan is a standing $0/month tier good for 75,000 monthly active users, and the self-hosted version has no usage limits at all, so you pay only for your server. The one free-Cloud catch: idle projects pause after a week of no traffic.

Firebase ships a backend in an afternoon, but the catch arrives later: per-operation billing that can spike a $0 month into four figures, a proprietary Firestore store you can only run on Google’s cloud, and closed source with no self-host escape hatch. Appwrite keeps the “backend without the work” and removes the catch — same core pieces, but open source and runnable on your own server with one command.

What Is Appwrite?

Appwrite is an open-source backend-as-a-service: one platform giving a frontend or mobile app everything it normally needs a server for, exposed through clean REST and SDK APIs. Two things set it apart. It was self-hosted first — it began as software you run yourself, with managed cloud added years later, so self-hosting is a first-class path and the whole stack runs in Docker. And it is genuinely open source under the permissive BSD 3-Clause license (GitHub), with no “open core” trick — the platform you self-host is the full platform. Under the hood it’s microservices behind an API gateway, backed by MariaDB and Redis, with isolated containers running your functions. Docs: appwrite.io/docs.

Is Appwrite Free? The Honest Breakdown

Appwrite Cloud has a real free plan — not a trial, a standing $0/month tier from the official pricing page:

Resource	Free plan	Pro plan (from $25/mo)
Bandwidth	5 GB / month	2 TB / month
Storage	2 GB	150 GB
Function executions	750,000 / month	3.5 million / month
Monthly active users	75,000	200,000
Projects	2 (shared resources)	1 dedicated (extra at $15 each)
Backups	None	Daily, kept 7 days
Sleeps / expires?	Pauses after ~1 week idle; no expiry	No idle pause
Region	Cloud region — see the official console/docs (self-host: wherever your server is)	Same
Commercial use	Allowed	Allowed
Credit card	Not required	Required

The standout is 75,000 monthly active users on a free plan — most BaaS tiers measure you in seats or rows, so a popular hobby app can live on $0 for a long time. The one honest asterisk: free Cloud projects pause after one week of inactivity. For a live app this never happens; for an occasional side project or an always-on demo it’s a real consideration — and a reason to self-host. Always check the current pricing page, because BaaS limits move.

Self-hosted Appwrite is free in the deeper sense: no quotas at all — no bandwidth cap, no MAU ceiling, no execution meter, no inactivity pause. Your only cost is the machine. Drop it on a cheap VPS or a permanently free box like an Oracle Cloud Always Free 4-core 24 GB ARM VPS for a true $0/month backend — one of the strongest “$0 backend” setups available in 2026.

The Products

Authentication — email/password, magic-link and OTP, phone (SMS), anonymous sessions, and 30+ OAuth2 providers, plus sessions, JWTs, verification, recovery, and team/role abstractions.
Databases — collections, documents, typed attributes, indexes, and relationships, governed by a per-document permission system. Backed by MariaDB, so you get document ergonomics on a SQL-grade core.
Storage — upload/download APIs, per-file permissions, and on-the-fly image transformation (width/height/quality/format), so you skip a separate thumbnail CDN. Antivirus scanning and encryption at rest available server-side.
Functions — isolated containers triggered by HTTP, cron, or Appwrite events. Runtime breadth is the standout: Node.js, Bun, Deno, Python, Go, Dart, PHP, Ruby, .NET, Java, Swift, and Kotlin — match each function to its language instead of a TypeScript-only layer.
Messaging — push (FCM/APNs), email (Mailgun, Sendgrid), and SMS (Twilio, Vonage) through one API, with topics and subscriptions first-class.
Realtime — WebSocket API to subscribe to any resource (collection, document, file, account) and get updates the instant they change, with no polling.
Sites (added 2025) — built-in hosting for static sites and SSR frameworks (Next.js, Astro, SvelteKit) from a Git repo, with global CDN, automatic SSL, and preview deploys. Host frontend and backend behind one dashboard.

All of it is reachable from official client SDKs (Web, Flutter, Apple, Android, React Native) and server SDKs (Node, Python, PHP, Dart, Ruby, Go, .NET, Java, Kotlin, Swift) — one consistent mental model across platforms, which is why Appwrite is a favorite in the Flutter and React Native communities.

Self-Host in Minutes

The install is a single Docker command (check the self-hosting docs for the current version tag — pin a version rather than latest in production):

docker run -it --rm \
  --volume /var/run/docker.sock:/var/run/docker.sock \
  --volume "$(pwd)"/appwrite:/usr/src/code/appwrite:rw \
  --entrypoint="install" \
  appwrite/appwrite:latest

An interactive setup asks for ports, hostname, and secrets, then writes a docker-compose.yml and .env and brings the stack up. Worth knowing:

Full stack via Compose — API gateway, MariaDB, Redis, and function-runtime containers. Plan for ~2 GB RAM as a comfortable floor.
You own upgrades and backups. “No usage meter” also means nobody backs it up for you — schedule DB dumps and snapshot your volumes.
Put it behind HTTPS. Appwrite can provision Let’s Encrypt certs during setup; never expose an internet-facing instance on plain HTTP.

If managing the Docker host is more than you want, pair Appwrite with a self-hosted PaaS like Coolify, which deploys and supervises the stack with a friendlier UI.

Your First App: Auth and a Document

Cloud or self-host, the code is identical except the endpoint URL. Install with npm install appwrite, then:

import { Client, Account, Databases, ID } from "appwrite";

const client = new Client()
  .setEndpoint("https://cloud.appwrite.io/v1") // or your self-hosted URL
  .setProject("<PROJECT_ID>");

const account = new Account(client);
const databases = new Databases(client);

// Register and log in — the entire auth flow
await account.create(ID.unique(), "me@example.com", "s3cret-password");
await account.createEmailPasswordSession("me@example.com", "s3cret-password");

// Write a document to a collection you defined in the console
await databases.createDocument(
  "<DATABASE_ID>", "<COLLECTION_ID>", ID.unique(),
  { title: "My first task", done: false }
);

// Subscribe to realtime changes
client.subscribe(
  "databases.<DATABASE_ID>.collections.<COLLECTION_ID>.documents",
  (event) => console.log("changed:", event.payload)
);

That’s a real backend — accounts, persisted data, live updates — in a handful of calls, with no server code of your own. The same objects exist in the Flutter, Apple, Android, and React Native SDKs with the same shape.

Appwrite vs Supabase vs Firebase

	Appwrite	Supabase	Firebase
License / source	BSD-3, open source	Apache-2/open source	Proprietary (Google)
Self-host	First-class, Docker	Yes, more involved	No
Database	Document API on MariaDB	PostgreSQL (raw SQL)	Firestore (NoSQL)
Functions	12+ runtimes	Edge Functions (TS/Deno)	Cloud Functions (JS/TS, Python)
Vector / AI search	Via integrations	Native pgvector	Via extensions
Billing model	Resource tiers	Resource tiers	Per-operation (can spike)
Free tier shape	75K MAU, pauses if idle	2 projects, pauses if idle	Generous but usage-billed

Firebase — most polished, most locked-in. Per-operation billing is the headline risk and closed source means no self-host exit. Pick it for Google’s ecosystem (Analytics, Crashlytics) if you accept the lock-in.
Supabase — the right call when data is relational and you want raw SQL. Native pgvector makes it the strongest choice for AI/RAG features next to relational data. See Supabase vs Neon.
Appwrite — wins on self-hosting ergonomics, multi-language functions, and SDK breadth. Best if you want the smoothest path to your own backend, write functions in Python/Go/PHP, or build in Flutter/React Native. It trades raw SQL power for document simplicity.

One economic data point: independent comparisons put self-hosted Appwrite at roughly 68% lower monthly cost than managed Firebase for teams above ~50,000 MAU, because you swap per-operation billing for a flat server cost.

Limits and Honest Caveats

Free Cloud pause — projects pause after a week of inactivity. Invisible for live apps; annoying for intermittent side projects or long-running demos. Self-hosting never pauses.
Self-hosting means you run it — upgrades, security patches, backups, monitoring, and uptime are yours. Budget for it, or pay for Cloud.
Document model, not raw SQL — collections and documents with a permission layer, not an open SQL console. Complex joins, window functions, and ad-hoc analytics are where Postgres-based platforms pull ahead.
Vector search is not native — no built-in vector index like Supabase’s pgvector. You can integrate a dedicated vector database, but it’s another moving part.

Frequently Asked Questions

Is Appwrite really free?

Yes, in two ways. Appwrite Cloud has a standing free plan (5 GB bandwidth, 2 GB storage, 750,000 function executions, 75,000 monthly active users, no credit card), and the open-source self-hosted version has no quotas at all — your only cost is the server. The Cloud free plan’s one catch: projects pause after a week with no traffic.

Appwrite vs Supabase — which should I choose?

Choose Supabase if your data is relational and you want raw PostgreSQL power and native vector search. Choose Appwrite if you want the smoothest self-hosting experience, serverless functions in many languages, and first-class SDKs for Flutter, React Native, and native mobile. Both are open source with real free tiers; database model (SQL vs document) and your platform are the deciding factors.

Can I self-host Appwrite for free?

Yes. Appwrite is designed to be self-hosted and installs with a single Docker command. There are no Appwrite-side fees and no usage limits when self-hosting — you pay only for the server. Run it on a cheap VPS or a permanently free Oracle Cloud Always Free ARM instance for an effectively $0/month backend.

What languages can Appwrite Functions use?

Node.js, Bun, Deno, Python, Go, Dart, PHP, Ruby, .NET, Java, Swift, and Kotlin. You can mix runtimes within a project, matching each function to the language best suited to its job.

Bottom Line

Appwrite gives you Firebase’s convenience without Firebase’s terms — auth, database, storage, multi-language functions, messaging, realtime, and hosting in one open-source platform, run on Appwrite’s cloud or your own server.

Launching a small app fast? The Cloud free plan carries 75,000 MAU at $0 — just remember idle projects pause after a week.
Want a backend you truly own? Self-host with one Docker command on a cheap VPS — or a free Oracle Cloud ARM box — for no usage meter and no lock-in.
Building in Flutter, React Native, or a polyglot stack? Appwrite’s SDK breadth and 12+ runtimes make it the most comfortable BaaS of the three.

If your data is relational and SQL-first, Supabase may suit you better; if you want Google’s ecosystem and accept the lock-in, Firebase is there. But for an open-source backend you can start free and self-host forever, Appwrite keeps the easy parts and hands you the keys.

Coolify: Free Self-Hosted App Hosting (Your Own Heroku)

toolfreebie — Thu, 20 Aug 2026 07:04:03 +0000

Quick answer: Coolify is a free, open-source (Apache 2.0) self-hosted PaaS — a Heroku/Vercel/Netlify alternative you install on your own server with one command. There are no feature gates, user limits, or usage meters: the only cost is the server itself, which can be $0 if you run it on an Oracle Cloud Always Free ARM VPS. The optional Coolify Cloud ($5/month) only hosts the control panel, not your apps.

Managed platforms give you push-to-deploy for free — until traffic, a database, and a worker turn the free tier into an $80/month bill. Coolify closes that gap: it gives a cheap VPS you own the same Git-driven deploys, automatic HTTPS, and one-click databases you were renting. You bring the server; Coolify brings the platform.

Free Tier at a Glance

Dimension	Coolify (self-hosted)
Cost	$0 — Apache 2.0, no feature gates. You pay only for the server, which can be $0 on an Oracle Always Free VPS
Resources	Whatever your server has. Coolify needs min 2 vCPU / 2 GB RAM / 30 GB disk (idles ~800 MB); 4 cores / 8 GB is comfortable
What you can deploy	Anything containerizable — Node, Python, Go, PHP, Rust, static sites, Docker Compose — plus 280+ one-click services and managed databases
What you can’t	Nothing is platform-gated; you’re limited only by your server’s size. It’s not managed hosting — no one runs the box for you
Sleeps?	No — it’s your always-on server
Expires?	No — free forever, no trial clock
Commercial use	Yes — Apache 2.0, no restrictions
Region / country	Wherever your server is — you choose the provider and location
Credit card	Not for Coolify itself (free software). Your server provider may require one

What Is Coolify?

Coolify is a self-hosted Platform-as-a-Service. You install it on a Linux server you control — a VPS, bare metal, even a Raspberry Pi — and it becomes a control plane that orchestrates Docker containers, configures a reverse proxy, provisions TLS, and watches your Git repos for changes. You manage everything from a web dashboard instead of hand-editing docker-compose and Nginx. It’s 57,000+ GitHub stars on coollabsio/coolify as of mid-2026.

Git-driven deploys. Connect GitHub, GitLab, Bitbucket, or Gitea and Coolify rebuilds on every push — via Nixpacks (zero-config buildpacks), a Dockerfile, or Docker Compose.
Automatic HTTPS. Traefik (or Caddy) handles routing and Let’s Encrypt certificates. Point a domain at your server, type it in, and you get a working https:// URL — no manual certbot.
No vendor lock-in. Coolify writes standard Docker configs to your server. Stop using it and your containers and data are still sitting on a machine you own.

Is Coolify Really Free?

Yes — the cleanest “free” in this category, because there’s no usage meter to run out of. Self-hosted Coolify is Apache 2.0 with no feature gates, no user/app/server limits, no “upgrade to unlock” walls. Everything Coolify does, the free version does. Your only cost is the server you were paying for anyway.

The paid product, Coolify Cloud, does not host your apps — you still bring your own servers. It hosts the Coolify control panel itself, so you don’t dedicate a server to running Coolify or keep it patched.

Option	Cost	What you get
Self-hosted (Apache 2.0)	$0	Full platform, all features, unlimited apps/users/servers. You host the Coolify instance.
Coolify Cloud	$5/month (≈$4 billed annually)	Coolify hosts the control panel; connect up to 2 servers. +$3/mo per extra server.

The honest reading: the free self-hosted version is the real product, and most individuals and small teams never need anything else. Cloud’s $5/month only buys you out of maintaining the Coolify instance — worth it if you run many servers and don’t want a single point of failure, but unnecessary for “one VPS, Heroku-on-it.”

What You Get on the Free Version

Because there are no tiers, the free version is the entire feature set:

280+ one-click services — WordPress, Ghost, n8n, Plausible, Uptime Kuma, MinIO, Appwrite, Supabase, and hundreds more, deployed with sensible defaults.
Managed databases — PostgreSQL, MySQL, MariaDB, MongoDB, Redis, KeyDB, Dragonfly, or ClickHouse, with scheduled backups to S3-compatible storage.
Flexible builds — Nixpacks, Dockerfile, Docker Compose, or static site — covering Node, Python, Go, PHP, Rust, Ruby, anything containerizable.
Preview deployments — spin up a temporary environment per pull request, torn down when the PR closes.
Multi-server orchestration — one instance manages many remote servers over SSH.
Auto-SSL, auto-deploy, notifications — Traefik/Caddy with Let’s Encrypt, Git webhooks, and deploy alerts to Discord, Telegram, Slack, or email.

Where to Run It (System Requirements)

From the official installation docs:

Spec	Minimum	Comfortable (production)
CPU	2 cores	4 cores
RAM	2 GB	8 GB
Storage	30 GB free	150 GB
Architecture	64-bit AMD64 or ARM64

Coolify idles at roughly 800 MB of RAM, so 2 GB is fine to learn on but a couple of real apps plus a database want 4 GB+. The key detail: Coolify runs on ARM64, and the Oracle Cloud Always Free tier gives you a 4-core, 24 GB ARM VPS at no cost, forever. That combination is the closest thing to a permanently free, full-featured self-hosted Heroku in 2026.

Install Coolify in 5 Minutes

SSH into a fresh server (as root or sudo) and run the official script — it installs Docker if missing, sets up Coolify’s containers, and starts the dashboard:

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash

It prints a URL, typically http://YOUR_SERVER_IP:8000. Open it and you land on a one-time registration screen. Register immediately — the first account becomes admin, and leaving that open on a public IP is the one security mistake to avoid. Then point Coolify at a domain (add an A record, set it in settings) and Traefik issues Let’s Encrypt certificates automatically.

Deploy Your First App from Git

Create a project — a container for related resources (app, database, cache). Pick the server and environment.
Add a resource → Public/Private Repository — paste a GitHub URL, or connect via the Coolify GitHub App for private repos and webhooks.
Pick a build pack — leave it on Nixpacks (auto-detects Node, Python, Go, PHP, Rust) or choose Dockerfile/Compose if your repo has one.
Set domain and env vars — Coolify wires up the proxy and SSL; env vars are stored encrypted.
Deploy — Coolify clones, builds, starts the container, routes the domain, issues a certificate, and streams build logs live.

After this, every push to the configured branch triggers a zero-downtime redeploy (health-checked before switching traffic). Need a database? Add a resource → Database → PostgreSQL and Coolify gives you a managed instance with an internal connection string — no apt install postgres.

One-Click Services and Self-Hosted Apps

A huge part of Coolify’s appeal is the 280+ one-click templates — pre-packaged deployments of popular open-source software. You click, tweak a few settings, and Coolify stands up the whole stack (app, database, volumes, proxy routes):

Content & sites: WordPress, Ghost, Directus, Strapi, Outline
Automation & dev tools: n8n, Gitea, Appsmith, NocoDB, Metabase
Analytics & monitoring: Plausible, Umami, Uptime Kuma, Grafana
Backend & storage: Supabase, Appwrite, MinIO, PocketBase
AI & productivity: Open WebUI, Nextcloud, Vaultwarden

This is where Coolify becomes “your personal cloud.” Each service lands on your server, behind your domain, with SSL, in minutes — and costs nothing beyond the server you’re already paying for.

Coolify vs Dokploy vs CapRover vs Managed Hosting

Platform	Model	Cost	Strengths	Watch-outs
Coolify	Self-hosted PaaS (Apache 2.0)	Free (your server)	Huge catalog, multi-server, Docker Compose, big community, preview deploys	You own uptime & security
Dokploy	Self-hosted PaaS (Apache 2.0)	Free (your server)	Clean UI, Docker Swarm-based, Traefik built in	Younger, smaller template library
CapRover	Self-hosted PaaS (Apache 2.0)	Free (your server)	Mature, stable, CLI-friendly	Older UI, Swarm only, less active
Railway	Managed PaaS	~$5/mo + usage	Zero ops, instant, great DX	Costs scale; you don’t own infra
Render	Managed PaaS	Free tier + paid	True free tier, managed databases	Free services sleep; usage-based above it

Coolify, Dokploy, and CapRover are the same category — you bring a server, they give it a platform. Coolify wins on breadth (largest catalog, Compose support, multi-server, most active community), Dokploy is the sleek Swarm-based up-and-comer, and CapRover is the battle-tested veteran. Railway and Render are the other side — they manage the server for you, worth real money when your time is scarce, but you pay per usage and never own the machine.

When to Self-Host — and When Not To

One small app, want zero ops? → Use a managed free tier like Render or other free hosting. Don’t take on server maintenance for a single hobby project.
Static sites or a frontend? → Use Vercel, Netlify, or Cloudflare Pages — a self-hosted PaaS is overkill.
Several apps, want managed databases, hate per-usage bills, comfortable with a server? → This is Coolify’s sweet spot. One VPS, many apps, auto-SSL, push-to-deploy, flat cost (or free on Oracle).
Can’t tolerate being responsible for uptime, patching, and backups? → Stay managed. Self-hosting means you are the on-call engineer.

Limits and Honest Caveats

You are the ops team. Coolify automates deploys, SSL, and proxying, but OS updates, firewall config, disk monitoring, and disaster recovery are still yours. Configure the built-in S3 backups on day one.
A single server is a single point of failure. If Coolify and all your apps share one VPS and it goes down, so does the dashboard you’d fix it from. For anything important, separate the control panel from production apps.
The 2 GB minimum is really a minimum. Coolify idles near 800 MB, and builds (especially Node) are memory-hungry. Budget 4 GB+ for real workloads — or take the 24 GB Oracle ARM box.
Beta cadence. Coolify moves fast and the v4 series spent a long stretch in beta. Read release notes and back up before upgrading a production instance.

Frequently Asked Questions

Is Coolify really free?

Yes. The self-hosted version is Apache 2.0 with no feature gates, user limits, or application limits — the full platform is free software. Your only cost is the server. The optional Coolify Cloud ($5/month) doesn’t host your apps; it hosts the control panel so you don’t maintain that instance yourself.

What are the minimum requirements?

A 64-bit Linux server (AMD64 or ARM64) with at least 2 CPU cores, 2 GB RAM, and 30 GB free storage. For comfortable production use with several apps and databases, 4 cores and 8 GB is a better target. Coolify itself idles at roughly 800 MB of RAM.

Can I run Coolify for free forever?

Effectively yes, if you pair it with a free server. Coolify supports ARM64, and the Oracle Cloud Always Free tier provides a 4-core, 24 GB ARM VPS at no cost indefinitely. Free software on free hardware is a permanently free, full-featured self-hosted PaaS.

Coolify vs Railway — what’s the difference?

Railway is fully managed: it owns the servers and you pay per usage with zero ops. Coolify is self-hosted: you own the server and pay only your hosting provider, but you’re responsible for upkeep. Choose Railway to never touch a server; choose Coolify for predictable flat cost and full control.

Bottom Line

Coolify closes the gap that used to force you onto a managed platform: it gives a server you already own the same push-to-deploy, auto-SSL, one-click-database experience you were renting — for free, as Apache-2.0 software, with no usage meter and no feature gates. Have a VPS and several apps? Install it with one command. Want it truly free? Run it on an Oracle Cloud Always Free ARM VPS. Just one small app with no desire to own a server? Reach for a managed free tier like Render instead.

Open WebUI: Free Self-Hosted ChatGPT for Ollama

toolfreebie — Thu, 20 Aug 2026 06:58:34 +0000

Quick answer: Open WebUI is a free, open-source, self-hosted ChatGPT-style interface for your local models and any OpenAI-compatible API. It auto-discovers Ollama models and adds document RAG, live web search, multi-user accounts, image generation, and a phone-friendly PWA — all running on your own hardware, all private, no fees or quotas. The only catch is a 2025 license clause that restricts rebranding it at scale; normal self-hosting is fully unrestricted.

Running a local model in a terminal is easy. But you want a real chat window — history, a model picker, drag-in PDFs, a search box, and access from your phone without sending tokens to anyone else’s server. Open WebUI is that window: a self-hosted web UI you run on your own machine that wraps your local models and remote APIs alike.

What Is Open WebUI?

Open WebUI is a browser-based front end for LLMs — a Python (FastAPI) backend with a Svelte UI, shipped as one Docker image or a pip package, designed to run entirely offline. It does not run inference itself; it’s the UI and orchestration layer that talks to a model backend over an API. That backend can be:

Ollama, on the same box or another machine — the original and tightest integration.
Any OpenAI-compatible endpoint — OpenRouter, Groq, Together, Mistral, local servers like llama.cpp or vLLM, or a unifying proxy like LiteLLM.

That decoupling makes it equally useful as a private front end for local-only models and as a single dashboard over a dozen cloud APIs. Docs live at docs.openwebui.com; source is on GitHub.

Is Open WebUI Free? The License Question

Yes — free and open source, with no paid tiers, token quotas, or telemetry you can’t disable. You can use it commercially. The one asterisk: in 2025 the project moved from MIT to a customized BSD-3-Clause license with an added branding-protection clause. You may not remove or alter the “Open WebUI” name and logo unless:

Your deployment serves a small number of users (a threshold the license defines), or
You are a contributor granted permission, or
You obtain an enterprise license.

For a personal install, home lab, or small team, this never comes up — you run it as-is. It only matters if you intend to white-label Open WebUI at scale. Because terms evolve, read the current LICENSE file rather than any blog post — including this one. For self-hosting, Open WebUI is fully free and unrestricted.

Install in 5 Minutes

Option A: Docker (Recommended)

If Ollama already runs on the same machine, this single command starts Open WebUI and wires it up automatically:

docker run -d \
  -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

Then open http://localhost:3000. Key flags: -p 3000:8080 maps the container’s internal port 8080 to host port 3000; -v open-webui:/app/backend/data is the named volume holding all persistent state (accounts, chat history, documents) — keep it and your data survives upgrades; --add-host=host.docker.internal:host-gateway lets the container reach Ollama on the host (default http://host.docker.internal:11434); --restart always brings it back after a reboot. An :ollama tagged image bundles both if you want them in one container. For cloud APIs only, you don’t need Ollama at all.

Option B: pip (Python 3.11)

It requires Python 3.11 specifically — newer or older can fail on dependencies, so use a virtual environment pinned to 3.11:

pip install open-webui
open-webui serve

That starts the server on http://localhost:8080, with data on your local filesystem instead of a Docker volume. Docker remains the path the maintainers test most heavily.

First Run

Whichever route you take, the first account you create becomes the administrator with full rights. Claim your own admin account immediately, and for any multi-user deployment enable admin approval for new sign-ups before sharing the URL.

Connect Any Model: Ollama and OpenAI-Compatible APIs

Open WebUI speaks two model protocols at once — local models and cloud APIs side by side in the same picker. If Ollama is reachable, it lists every model you’ve pulled automatically; you can even pull new models from inside the admin settings. See the companion guide on running AI models locally with Ollama.

Under Settings → Connections, add any number of OpenAI-compatible endpoints, each with a base URL and API key:

Provider	Base URL	What you get
OpenRouter	`https://openrouter.ai/api/v1`	300+ models, including free-tier ones, behind one key
Groq	`https://api.groq.com/openai/v1`	Very fast Llama and other open models, generous free tier
Google Gemini	`https://generativelanguage.googleapis.com/v1beta/openai`	Gemini models via the OpenAI-compatible shim
LiteLLM proxy	your self-hosted proxy URL	One endpoint fronting all of the above

The last row is the most powerful pattern. Instead of pasting four provider keys into Open WebUI, run a LiteLLM gateway, register all providers there once, and point Open WebUI at a single endpoint. LiteLLM handles routing, spend tracking, virtual keys, and fallbacks; Open WebUI just sees one tidy model list.

Beyond Chat: The Features That Matter

RAG over your documents. Upload PDFs, text, and Office files into a conversation or a reusable Knowledge collection, then reference them with # in a prompt. Open WebUI chunks, embeds, and retrieves the relevant passages so answers are grounded in your files. Paste a URL after # to pull a web page in on the fly. The embedding model is configurable, including local ones so the whole pipeline stays offline.
Web search. Toggle live search on a message and the model answers with current sources. Backends include self-hosted SearXNG, Brave, Google Programmable Search, Tavily, and others, configured with an API key or URL in admin settings.
Multi-user accounts and roles. Real RBAC (admin, user, custom groups), per-model access permissions, and admin approval for new sign-ups — a first-class feature, not an afterthought.
Model builder, prompts, pipelines. Save custom assistants (base model + system prompt + tools + knowledge), a shared prompt library, plus Pipelines and Functions to inject custom Python (rate limiting, filtering, custom RAG, monitoring) into the request flow.
Tools, image generation, voice. Tool calling via OpenAPI-compatible tool servers (its bridge to the Model Context Protocol ecosystem), image gen via AUTOMATIC1111/ComfyUI or a hosted API, and hands-free voice/video call modes.
Works on your phone. It’s a PWA — open your server URL on mobile, add to home screen, and you have a native-feeling AI app talking to models on your own hardware.

Open WebUI vs LibreChat vs Lobe Chat vs AnythingLLM

Tool	Best at	Local model support	Multi-user	License note
Open WebUI	All-rounder; best Ollama integration; RAG + web search + multi-user in one	Excellent (native Ollama)	Yes, with RBAC	BSD-3 + branding clause
LibreChat	Many cloud providers, plugins, agents; familiar ChatGPT-like UX	Good (via endpoints)	Yes	MIT
Lobe Chat	Most polished UI, plugin marketplace, fast setup	Good (via endpoints/Ollama)	Limited	Open source (check current)
AnythingLLM	Document-chat and agents; simple desktop app option	Good	Yes (workspaces)	MIT

Open WebUI is the default pick if you run local models and want one tool that does everything, with the tightest Ollama integration. LibreChat wins if your priority is many cloud providers and a permissive MIT license for white-labeling. Lobe Chat wins on visual polish and its plugin marketplace. AnythingLLM is built around document chat and ships a desktop app — the simplest path when your core need is “talk to my documents.”

Limits and Honest Caveats

It does not run models. With no Ollama and no API configured, it’s an empty chat box. Backend quality, speed, and cost are yours to supply — Open WebUI can’t make a slow model fast or a rate-limited tier unlimited.
Resource footprint. The UI is lightweight, but local RAG needs an embedding model and local inference needs the usual GPU/RAM. On a small VPS with no GPU it works fine as a front end for cloud APIs; plan the backend, not just the UI.
The branding clause. A non-issue for self-hosting and small teams, but if you plan a rebranded commercial product, read the current license or choose an MIT alternative like LibreChat or AnythingLLM.
Security is yours. The first account is admin. An instance exposed to the internet without auth, HTTPS, and approval-gated sign-ups is a liability — put it behind a reverse proxy with TLS and never expose the raw port.

Frequently Asked Questions

Do I need Ollama to use Open WebUI?

No. Ollama gives the tightest local-model integration, but Open WebUI works with any OpenAI-compatible API. You can run it purely as a front end for OpenRouter, Groq, or a LiteLLM proxy, with no local models at all.

What is the difference between Open WebUI and Ollama?

Ollama runs the models — it’s the inference engine that downloads and serves an LLM. Open WebUI is the interface you put in front: chat history, document RAG, web search, multi-user accounts, and a model picker. Ollama is the engine, Open WebUI is the dashboard.

Can Open WebUI chat with my documents (RAG)?

Yes. Upload documents or build a Knowledge collection, then reference them with the # symbol in a prompt. The embedding model is configurable, including local models so the entire pipeline can run offline.

Is Open WebUI safe to expose to the internet?

Only if you secure it. Put it behind a reverse proxy with HTTPS, require admin approval for new accounts, and never expose the raw port unauthenticated. The first account created becomes the administrator, so claim it before sharing the URL.

Bottom Line

Open WebUI turns a model into a product — wrapping the local LLM you can already run in a terminal with conversation history, document RAG, live web search, multi-user accounts, image generation, and a phone-friendly PWA, all self-hosted and free. Running Ollama? One Docker command auto-detects your models. Juggling cloud keys? Point it at a LiteLLM gateway for one private dashboard. Building a product on top? Read the license first — self-hosting is unrestricted, but the branding clause matters at commercial scale.

DEV Community: toolfreebie

groq/llama-3.3-70b-versatile is not on Groq's model list anymore

Neon's free plan is 100 small projects now, not one database

Groq's 14,400 requests a day is not for the chat models

Marker and Surya are Apache 2.0 — their model weights are not

Koyeb's Starter plan: closed to new signups, kept for existing orgs

Railway's Free plan costs $1 a month

A daily cron ping won't stop Oracle reclaiming your idle instance

Render's free tier doesn't cover background workers

GLM Free API: Zhipu’s Flash Models at Zero Cost

Is the GLM API free? The honest breakdown

Free vs paid: what scaling up costs

Get a key and make your first call

The killer feature: GLM as a free Claude Code backend

The GLM Coding Plan: subscription vs pay-per-token

GLM vs DeepSeek vs the free APIs you already use

Limits and honest caveats

Frequently Asked Questions

Is the GLM API really free?

Can I use GLM with Claude Code?

What’s the difference between GLM-4.7-Flash and FlashX?

GLM vs DeepSeek — which is better?

Bottom line

Related Reads

Appwrite: Free Open-Source Backend (Firebase Alternative)

What Is Appwrite?

Is Appwrite Free? The Honest Breakdown

The Products

Self-Host in Minutes

Your First App: Auth and a Document

Appwrite vs Supabase vs Firebase

Limits and Honest Caveats

Frequently Asked Questions

Is Appwrite really free?

Appwrite vs Supabase — which should I choose?

Can I self-host Appwrite for free?

What languages can Appwrite Functions use?

Bottom Line

Related Reads

Coolify: Free Self-Hosted App Hosting (Your Own Heroku)

Free Tier at a Glance

What Is Coolify?

Is Coolify Really Free?

What You Get on the Free Version

Where to Run It (System Requirements)

Install Coolify in 5 Minutes

Deploy Your First App from Git

One-Click Services and Self-Hosted Apps

Coolify vs Dokploy vs CapRover vs Managed Hosting

When to Self-Host — and When Not To

Limits and Honest Caveats

Frequently Asked Questions

Is Coolify really free?

What are the minimum requirements?

Can I run Coolify for free forever?

Coolify vs Railway — what’s the difference?

Bottom Line

Related Reads

Open WebUI: Free Self-Hosted ChatGPT for Ollama

What Is Open WebUI?

Is Open WebUI Free? The License Question

Install in 5 Minutes

Option A: Docker (Recommended)

Option B: pip (Python 3.11)

First Run

Connect Any Model: Ollama and OpenAI-Compatible APIs

Beyond Chat: The Features That Matter

Open WebUI vs LibreChat vs Lobe Chat vs AnythingLLM

Limits and Honest Caveats

Frequently Asked Questions

Do I need Ollama to use Open WebUI?

What is the difference between Open WebUI and Ollama?

Can Open WebUI chat with my documents (RAG)?

Is Open WebUI safe to expose to the internet?

Bottom Line

Related Reads