DEV Community: public apis

How to Vibe Code a Game Like Lagos Life: Free APIs, Prompts, and How to Survive the Traffic

public apis — Sat, 24 Oct 2026 21:02:30 +0000

On October 1, 2026 , Nigeria's Independence Day, a browser game called Lagos Life went live at 7 a.m. Its creator had reportedly been building it through the night with AI help. Within days it was everywhere on Nigerian X and TikTok: you create a character, get a job, buy food, pay rent in virtual naira and run into other players on the streets of Lagos. Within a week and a half, the company behind it had raised a $500,000 angel round.

The lesson for developers isn't "there's a secret API". It's that one person with an AI coding assistant, a sharp local idea and a handful of free APIs can ship something millions of people play. This guide shows how to build your own version: what to build in which order, what to tell your AI tool at each step, which free APIs make the world feel real, and the traps that cost Lagos Life real money and trust in its first weeks.

Note: we have no connection to Lagos Life or its developer, Vatar, and they haven't published their tech stack. Facts about the game come from public reporting, linked below. The build plan and API advice are ours, and we tested every API mentioned in October 2026.

What Lagos Life actually is (and why it spread)

Here's what's been reported, mostly by Techpoint Africa, TechCity, Innovation Village, The Condia and TheCable:

Date	What happened
Sep 26	Lagos Run, a danfo-driving browser game by another Nigerian developer, goes viral. It and The Sims are cited as inspirations.
Oct 1	Lagos Life launches in the browser after an overnight, AI-assisted build.
Oct 2	A brief outage. Every player gets ₦100,000 of virtual cash as an apology.
Oct 5	1.2 million players and 55,000–72,000 online at once on the live counter; a peak of over 109,000 concurrent players reported.
Oct 8	About 4.3 million players across 15 countries, and a later claim of 200,000+ online at once (company figures).
Oct 9	Vatar announces a $500,000 angel round, with founders of Mono, Terra Industries and Flutterwave among the investors.
Oct 11	10 million+ accounts and 49 million visits claimed. Accounts, not unique people; none of these numbers are audited.

How it makes money: players can buy "Game Naira" with real money through Flutterwave. It can't be cashed out. Brands buy in-game billboards and lagoon plots; reported prices went from ₦5,000 to ₦250,000 a week as the game grew. The founder said it made about $46,900 in its first four days, against hosting costs of roughly $6,000 a month.

Why it spread:

It's local. Danfo buses, Lekki rent, Yaba, the lagoon. Players recognise their own city and want to screenshot it.
It's a link. No app store, no download, no "Android only". A post on X opens straight into character creation.
It's social. Other real people are on the same map. That gives you something to post about.
The loop is simple. Work, eat, sleep, pay rent, show off. Everyone already understands it.

None of these needs a big team, which is exactly why it's worth studying.

Can you really vibe code a game like this?

Yes, with one big condition. AI tools are excellent at the first 80% : the map, the characters, the menus, the API calls. They're dangerously confident about the last 20%: money, multiplayer cheating, security and scale. Lagos Life's biggest public problems were in that last 20%. Hacked accounts and a loophole produced "trillion-naira" balances that the team had to wipe, and the servers needed an overload screen ("Lagos hit a small go-slow") within days.

So the approach below is: let the AI write the code, but you design the rules and check the risky parts yourself. You don't need to be a senior engineer for that, just to know what to ask and what to test.

The toolkit

An AI coding tool. Agentic tools that edit a real project (Claude Code, Cursor, Windsurf) are the best fit, because a game grows past what fits in one chat. Browser builders (Bolt, Lovable, Replit) get you a first playable version fastest but get harder to steer as the game grows.
A game framework the AI knows well. Lagos Life is 3D in the browser , and its creator announced that phones struggling with 3D now switch to a lighter view instead of crashing. For 3D, Three.js (or Babylon.js) with low-poly models; for your first version, Phaser in 2D is far easier and still works. AI tools write both fluently because there's so much example code online.
A backend with real-time support: Supabase (Postgres database, auth and realtime channels, with a free tier) is the least-setup option. A small Node server with Socket.IO gives you more control.
Hosting: Vercel or Netlify for the front end. For an always-on game server, a small VPS (DigitalOcean, which Lagos Life's privacy policy names, or Hetzner).
Free APIs for everything that makes the world feel real. That's the big section below.

Tip: before you start, write a one-page game design doc (the jobs, prices, needs, what happens when you're broke) and give it to the AI as a file in the project. AI tools are much better at following a written spec than at reading your mind across fifty prompts.

The build plan: 7 phases, with prompts

Build in this order. Each phase ends with something you can play, which keeps both you and the AI on track. The prompts are starting points; paste them in, then iterate.

Phase 1: A city you can walk around

Start with the map and a character, nothing else.

Create a Vite + Phaser 3 project for a top-down 2D life-sim set in Lagos, Nigeria.
(For 3D: Vite + Three.js, low-poly glTF models, and an automatic 2D/low-detail
fallback when the frame rate drops below 25 fps.)
One scene: a tile-based map with roads and 6 named areas (Yaba, Surulere, Ikeja,
Lekki, Victoria Island, Lagos Island) as labelled zones. A player character moves
with arrow keys/WASD on desktop and a virtual joystick on mobile. Camera follows
the player. Keep the total bundle small: this must load fast on a cheap Android
phone on a 3G connection.

Check: play it on your actual phone, on mobile data. Most of your players will be on mid-range Android phones with expensive data. If it's slow now, it'll be unplayable at scale.

Phase 2: The life loop

Now the "Sims" part: needs, jobs, money and rent.

Add a life simulation loop, following docs/game-design.md:
- Game time runs at 1 real minute = 10 game minutes. Show the clock and day.
- Needs: hunger and energy (0-100), decaying over time. Sleeping restores energy.
- Jobs at specific buildings: start a shift, get paid at the end of it.
- Rent is due every 7 game days. If you can't pay, you get evicted to a cheaper area.
- All money is stored as whole kobo (integers), never decimals.
Put all game rules in one module (rules.ts) as pure functions so they can be tested.

Check: ask the AI to "write tests for rules.ts covering a full work day, rent day and going broke". Pure functions plus tests are the best defence against the AI quietly changing a rule in a later prompt.

Phase 3: The real-world layer (free APIs)

This is what makes your game feel like the city, not a city: the real weather, real neighbourhoods, real holidays. See the API section below for which ones to use and their gotchas.

Add a "world" service on the server that, every 15 minutes, fetches current Lagos
weather from Open-Meteo (no API key) and today's Nigerian public holidays from
Nager.Date, and broadcasts them to all players. Effects: rain makes commutes
30 game minutes longer and costs extra energy; public holidays close workplaces.
Sync the day/night cycle to real Lagos sunrise and sunset from the
Sunrise-Sunset API. Cache everything; players must never call these APIs directly.

Check: that last sentence matters. AI tools love to put fetch() calls in the client "for simplicity". With 100,000 players, that's 100,000 people hitting a free API, and you'll be blocked within minutes.

Phase 4: Multiplayer

Seeing other people on the map is what turns a toy into Lagos Life.

Add multiplayer with Socket.IO (or Supabase Realtime). The server is authoritative:
clients send movement *intents* (direction), the server validates speed and walls,
updates positions and broadcasts them. Only send each player the positions of
players within their area of interest (a spatial grid, 3x3 cells around them),
not everyone on the map. Throttle position updates to 10 per second.

Check:"server is authoritative" and "area of interest" are the two phrases that matter. Without the first, anyone can open the browser console and teleport. Without the second, the server tells every player about every other player, so traffic grows with the square of your player count. In our simulation of 20,000 players on a large map, a simple grid cut each update from 19,999 recipients to about 19.

Phase 5: The economy (do not skip this)

This is where AI-generated code most often goes wrong, and where Lagos Life reportedly got hurt. The usual bugs:

Read-then-write races. Two "send money" requests read the same balance at the same time and both succeed.
Double-counted retries. A flaky connection resends a transfer, and it goes through twice.
Trusting the client. Negative amounts, decimals, or "my balance is now 1,000,000" sent from the browser.

Rebuild all money handling in the database, not in game code:
- A wallets table with a CHECK (balance >= 0) constraint, amounts in integer kobo.
- Transfers between players run in one transaction with a conditional update
  ("UPDATE ... SET balance = balance - X WHERE id = ? AND balance >= X") and an
  idempotency key, so replays are ignored.
- Every naira that enters the game (salary, purchase) or leaves it (rent, shops)
  is recorded in a supply_changes table.
- Add a reconcile job that checks SUM(wallet balances) == SUM(supply_changes)
  every 5 minutes and alerts me if it drifts.
Then write tests that try: double-sending, negative amounts, overdrafts and
1,000 concurrent transfers. Show me the results.

Check: the reconcile job is your smoke alarm. Remember that you can break the economy too: Lagos Life's ₦100,000-per-player outage apology was, in effect, minting money for millions of accounts at once. Record grants like that as supply changes, so you can see their effect on prices. We built this pattern and then deliberately "hacked" a balance directly in the database; the reconcile check flagged the exact drift immediately. If Lagos Life's loophole had been caught in hours rather than after it spread, the clawback would have been much smaller.

Phase 6: Chat and safety

Players will talk, flirt, argue, and someone will try to scam someone. Plan for it.

Add proximity chat (only players within the same area of interest see messages).
Rate-limit to 1 message per 2 seconds per player. Filter messages with a local
word list (include Nigerian Pidgin and Yoruba insults I'll provide), and run the
PurgoMalum API asynchronously as a second pass for reported messages only.
Add report and block buttons. Block any message that contains a phone number,
bank account number or payment link, with a warning about scams.

Check: the scam filter isn't optional. Within days of Lagos Life going viral, accounts were being hacked, people were offering to "buy and sell game cash for real naira", and an unofficial crypto token appeared using its name. Your game will attract the same.

Phase 7: Payments and launch

If you sell virtual currency, the money is real even when the naira on screen isn't.

Add a "Buy Game Naira" flow with Flutterwave Standard checkout. Credit coins ONLY
after the server calls Flutterwave's verify endpoint
(GET /v3/transactions/{id}/verify) and checks: data.status is "successful",
tx_ref matches our order, currency is NGN and amount matches the pack. Use the
Flutterwave transaction id as an idempotency key so the webhook and the redirect
can't both credit. Write clear terms: Game Naira can't be withdrawn or exchanged.

Check: Flutterwave's response has two "statuses": the top-level status is "success" when the transaction is found, while data.status must be "successful" for the payment to have gone through. Mixing them up is a classic way to hand out free coins.

The free APIs that make a game world feel real

Every API here is free, and the ones marked "no key" need no sign-up. We tested all of them in October 2026; click through to the directory for live status and uptime.

Feature	API	Key?	What we learned testing it
Live weather	Open-Meteo	No	Fast and reliable. Returns WMO weather codes (≥ 51 is rain, ≥ 95 thunderstorms), which map neatly to game effects.
Day and night	Sunrise and Sunset	No	Times come back in UTC. Lagos is UTC+1, so a "05:32" sunrise is 6:32 a.m. local. Convert, or your city wakes up an hour early.
Public holidays	Nager.Date	No	Has Nigeria (`/PublicHolidays/2026/NG`). Fetch once a year and store it.
Real places	Nominatim / Photon	No	Nominatim allows 1 request per second and requires a User-Agent. Geocode your map's places once, save the coordinates, and never call it from the game. Photon (also OpenStreetMap data) is better for search-as-you-type.
Avatars	DiceBear	No	The same username always gives the same avatar: free profile pictures with no image storage. Licences differ per style, so check the one you pick allows commercial use.
NPC names and faces	RandomUser	No	Doesn't support Nigerian names. `?nat=ng` silently returns another nationality. Write your own list of Nigerian names.
Exchange rates	ExchangeRate-API open endpoint	No	Has NGN; updates daily; the free endpoint asks for attribution. Frankfurter doesn't have NGN (it only covers ECB currencies).
Chat filtering	PurgoMalum	No	Works, and you can add your own words with `add=`, but it took over 4 seconds to answer in our test. Too slow for live chat; use it as a second pass. It knows English profanity only.
Quiz nights	Open Trivia DB	No	Thousands of questions, but limited to one request every 5 seconds per IP. Fetch in batches and store them.
Mini-games	Deck of Cards	No	Ready-made shuffling and dealing for a card table in a bar.

Three rules apply to all of them:

The server calls the APIs, never the players. Free APIs are free because they're used politely.
Cache by how often the data changes. Weather every 15 minutes, holidays once a year, places once ever.
Have a fallback. If the weather API fails, the game should default to "sunny", not crash.

For more ideas, browse free game and comics APIs and every API that needs no key.

What AI won't warn you about

After testing this build, these are the things we'd check in any AI-generated game before launch:

Secrets in the front end. Ask the AI: "list every API key or secret and where it's used". Payment keys must only exist on the server.
Database rules. If you use Supabase, ask it to "audit row-level security on every table". A missing policy means any player can edit any wallet from the browser console.
Sign-up abuse. Questions were raised about how many Lagos Life accounts were real people. Add email verification and a CAPTCHA (Cloudflare Turnstile is free) before launch, not after bots arrive.
Age and data rules. Lagos Life became 18+ and publishes a privacy policy naming its providers. Nigeria's data protection law applies to you too. Write the policy before you collect a single email.
Your own name. Within days there were fake Lagos Life tokens and cash-sellers. Register your handles early, and pin an "official links only" post.

How Lagos Life handled the traffic, and how you would

This is the part most "I built a game in a weekend" stories skip, and it's where a viral game lives or dies. Lagos Life went from zero to a reported 109,000+ people online at once in days. Here's what that means technically, what's known about how Lagos Life coped, and the architecture that survives it.

Total players don't matter. Concurrent players do.

"1.2 million players" sounds terrifying, but on the morning of October 5 the live counter showed about 55,000 online , and later that day around 72,000. Roughly 5–6% of all accounts were playing at the same moment. That's normal, and it's the number to design for: servers, bandwidth and database connections scale with concurrent players , not sign-ups.

A sign-up costs you one database row. A player who's online costs you an open WebSocket connection, position updates ten times a second, chat messages, and a slice of CPU on a game server, for every minute they play.

What we know about how Lagos Life coped

The developer hasn't published a post-mortem, but the public record shows the classic pattern of a game scaling live, in production:

An early outage (October 2). The game went down briefly a day after launch. The team apologised by giving every player ₦100,000 of virtual cash: free to issue, and very good for goodwill.
An overload screen. Players reported a "Lagos hit a small go-slow" screen when the servers were busy. Showing a friendly, on-brand "we're full" message instead of an error is exactly the right move (see admission control below).
Adaptive graphics. Phones that couldn't handle the 3D city were switched to a lighter view instead of crashing. That's a scaling fix too: the cheapest server request is the one a crashed client never retries.
Chat pressure. Developers on X speculated that in-game chat was the biggest bandwidth problem, because a social game's chat can turn into "everyone talks to everyone". That's speculation, but it's the right instinct, as the maths below shows.
The bill. The founder cited hosting of about $6,000 a month , and the privacy policy names DigitalOcean as the host.

The maths of 100,000 people on one map

Here's a back-of-envelope estimate for a shared map, assuming each position update is 12 bytes (a player ID plus x and y) and the server sends ten updates a second:

Approach	Data each player receives	Total server output (100,000 online)
Naive: send everyone's position to everyone	~12 MB per second (impossible on mobile)	~1.2 terabytes per second
Area of interest: only the ~20 nearest players, batched into one packet per tick	~3 KB per second	~300 MB per second
Same, at 5 updates per second	~1.5 KB per second	~150 MB per second

The first row is why naive multiplayer code (exactly what an AI writes if you don't ask for more) falls over at a few thousand players. The second row is very manageable.

It also matters for your players' data bundles : at 3 KB per second, an hour of play is about 11 MB of mobile data, plus the one-off download of the game's assets. In Nigeria, where players pay for every megabyte, that's a feature worth bragging about.

The architecture that survives going viral

Each of these is a prompt you can give your AI tool, one at a time:

Put every static file on a CDN. HTML, JavaScript, 3D models, textures, sounds and avatars should be served by Cloudflare, Vercel or Netlify, never by your game server. Compress 3D models (glTF with Draco or Meshopt compression, and KTX2 textures) so the first load stays small.
Split "web" from "game". Sign-up, profiles, the shop and the stats page are ordinary stateless HTTP endpoints that can scale out behind a load balancer. The live world (WebSocket connections, positions, chat) runs on separate game servers , which hold state in memory.
Shard the city into zones. One game server process per area (Island, Mainland, Lekki…), with players handed off when they cross a boundary. If one zone gets busy, it slows down alone, and you can add instances of the busiest zones (Lekki on a Friday night) without touching the rest.
Area of interest plus tick batching. As in Phase 4: only send nearby players, and send one combined binary packet per tick rather than one JSON message per player. Send distant or idle players less often.
Treat chat as its own service. Proximity chat only reaches players in the same area of interest; global or city-wide channels are rate-limited and paginated; messages are kept for hours, not forever. Use Redis pub/sub so chat scales independently of the game servers.
Keep positions out of the database. Writing 100,000 positions ten times a second would melt any database. Positions live in game-server memory and are saved as snapshots every minute or two. Only the important things (money, purchases, property) go straight to Postgres, in transactions, through a connection pooler like PgBouncer.
Cache the stats page. A "live players" counter that every visitor reloads is one of the most popular pages. Compute it once every 30 seconds and serve the cached number.
Admission control: your "go-slow" screen. Decide the maximum players per zone and per server before launch. When you're full, put new arrivals in a queue with their position ("you're number 340"), instead of letting everyone in and making the game unplayable for all.
Adaptive quality on the client. Detect a low frame rate and drop to fewer players drawn, lower-detail models, or a 2D view. Lagos Life's 3D fallback is this exact idea.
Autoscale on the right signal. Scale game servers on open connections and tick time (how long each 100 ms tick takes to compute), not on CPU alone. If a tick takes longer than the tick interval, players feel lag before any CPU graph looks scary.

A combined prompt to start with:

Refactor the multiplayer server for scale: (1) split the map into zones, one
process per zone, with handoff between zones; (2) use a spatial grid for area of
interest and send one binary snapshot per 100 ms tick with only nearby players;
(3) move chat to a separate service using Redis pub/sub with per-player rate
limits; (4) keep positions in memory and snapshot to Postgres every 60 seconds;
(5) add an admission queue with a friendly "Lagos is full" screen when a zone
reaches MAX_PLAYERS_PER_ZONE. Explain each change before making it.

What it costs

Bandwidth is usually the surprise line on the bill, and the provider you pick changes it by roughly 9×. Using the ~300 MB per second estimate above for 100,000 concurrent players (about 1.1 TB per hour at peak):

Provider pricing for outbound data	Cost per peak hour	4 peak hours a day for a month
~$0.01 per GB (e.g. DigitalOcean or Hetzner overage)	~$11	~$1,300
~$0.09 per GB (big-cloud list price, e.g. AWS)	~$97	~$11,700

Add servers, a managed database, Redis and a CDN, and a game at Lagos Life's reported peak landing somewhere in the low thousands of dollars a month on a budget host is plausible. On a big cloud with default settings, it could easily be several times that. Choose a host with cheap or bundled egress before you go viral.

Load test before the internet does it for you

Ask your AI tool to write a load test with k6 or Artillery that opens 1,000, then 5,000, then 20,000 fake WebSocket players, has them walk around and chat, and records tick time, memory and messages per second. Run it against a staging server the same size as production. The numbers tell you how many players one server handles, so when the next spike comes you know exactly how many to add, and which screen people see when you run out.

Your launch checklist

Loads in under 5 seconds on a mid-range Android phone over mobile data
Opens straight into character creation from a shared link
A shareable "my character" card (avatar + job + area) for X and TikTok
Server-authoritative movement and money, with tests
Area-of-interest updates, zones and an admission queue, load-tested
Economy reconcile job running, with alerts
Chat filter, scam-pattern blocking, report and block
Payments credited only after server-side verification
Privacy policy, terms (no cash-out), age gate
Official social handles registered and pinned

The takeaway

Lagos Life worked because it was local, instant and social , and it was built fast because AI tools now handle most of the code. You can do the same for Accra, Nairobi, Jo'burg or your own city. Let the AI build the world; you own the rules, the money and the safety. That split is the difference between a viral hit and a viral clawback.

New to APIs? Start with what a public API is, then browse the no-key API list for your city's real-world layer.

Best Free Weather APIs in 2026: 8 Options Tested and Compared

public apis — Sat, 24 Oct 2026 15:11:37 +0000

The short answer: for most projects in 2026, start with Open-Meteo. It needs no API key, allows 10,000 calls a day for non-commercial use and covers the whole world. If you need a commercial free tier with a key, WeatherAPI.com (100,000 calls a month) and OpenWeatherMap's One Call 3.0 (1,000 calls a day) are the strongest options. For US-only projects, the National Weather Service API is free, keyless and official.

That recommendation comes from data. Our directory tracks all 47 weather APIs in the public-apis list and checks each one every day. On October 24, 2026, 43 were online, 22 need no API key and 20 support CORS for browser calls. Below we compare the eight you're most likely to choose between, show working code, and explain which to pick for which job.

Free weather API comparison (October 2026)

API	API key	Free allowance	Commercial use on free tier	Notes
Open-Meteo	No	10,000 calls/day, 300,000/month	No (non-commercial)	Global forecasts, historical data, many weather models
OpenWeatherMap	Yes	1,000 One Call 3.0 calls/day	Yes, pay per call above the free amount	The most widely used; card may be needed for One Call 3.0
WeatherAPI.com	Yes	100,000 calls/month	Yes	Free plan: 3-day forecast, 1 day of history
Pirate Weather	Yes (free)	Generous free tier	Check terms	Dark Sky-compatible response format
Tomorrow.io	Yes	500 requests/day (25/hour)	Check terms	Hyperlocal forecasts and weather layers
Visual Crossing	Yes	Free plan with a daily record limit	Yes	Strong historical weather data
Weatherstack	Yes	100 calls/month	Yes	Paid plans from $9.99/month for 50,000 calls
US Weather (NWS)	No (User-Agent)	Free, fair use	Yes	US only, official National Weather Service data

Prices and limits were taken from each provider's pricing page in October 2026. Free tiers change, so check the provider's page before you commit.

1. Open-Meteo: the best free weather API without a key

Open-Meteo is the default choice for hobby projects, prototypes and research. There's no sign-up: you call the URL and get JSON back. Its free, non-commercial tier allows 600 calls a minute, 5,000 an hour and 10,000 a day. It combines forecasts from national weather services, and it also offers historical weather, marine and air-quality endpoints. It sends CORS headers, so you can call it straight from the browser.

const url = new URL("https://api.open-meteo.com/v1/forecast");
url.search = new URLSearchParams({
  latitude: "51.51",
  longitude: "-0.13",
  current: "temperature_2m,wind_speed_10m",
  daily: "temperature_2m_max,temperature_2m_min",
  timezone: "auto",
});

const res = await fetch(url);
const data = await res.json();
console.log(`Now: ${data.current.temperature_2m}°C`);
console.log("Next 7 days (max):", data.daily.temperature_2m_max);

The catch: the free endpoint is for non-commercial use only. A commercial product needs one of Open-Meteo's paid API plans, which start at 1 million calls a month.

2. OpenWeatherMap: the most popular, with a pay-as-you-go free tier

OpenWeatherMap is the API most tutorials use. Its current flagship, One Call API 3.0 , includes 1,000 free calls per day. Above that you're billed per call, and you can set a daily cap in your account to avoid surprise charges. Users report that One Call 3.0 asks for a payment card even if you stay within the free calls.

import os
import requests

params = {
    "lat": 51.51,
    "lon": -0.13,
    "units": "metric",
    "appid": os.environ["OWM_API_KEY"],
}
res = requests.get("https://api.openweathermap.org/data/3.0/onecall", params=params, timeout=10)
res.raise_for_status()
print(res.json()["current"]["temp"])

If you're moving off OpenWeatherMap, our OpenWeatherMap alternatives page ranks every comparable API.

3. WeatherAPI.com: the biggest commercial-friendly free tier

WeatherAPI.com offers 100,000 calls a month on its free plan , with paid plans from $7/month for 3 million calls. The free plan includes real-time weather, a 3-day forecast and one day of history. It also bundles extras like astronomy, time zone and IP-to-location lookups.

curl "https://api.weatherapi.com/v1/forecast.json?key=$WEATHERAPI_KEY&q=London&days=3"

4. Pirate Weather: a Dark Sky replacement

When Apple shut down the Dark Sky API, Pirate Weather rebuilt its response format from public NOAA and ECMWF model data. If you have old Dark Sky code, it's the closest drop-in replacement. The public-apis list marks it as keyless, but it now needs a free API key: requests without one return 401 Unauthorized.

curl "https://api.pirateweather.net/forecast/$PIRATE_WEATHER_KEY/51.51,-0.13?units=si"

5. Tomorrow.io: hyperlocal forecasts with tight limits

Tomorrow.io is strong on hyperlocal and minute-by-minute data. Its free plan is the tightest here: 500 requests a day, 25 an hour and 3 a second , resetting at midnight UTC. Map tiles count as requests too. It's best for a small dashboard, not for polling many locations.

6. Visual Crossing: best for historical weather

Visual Crossing is the pick when you need decades of history in one request, for example for analytics, insurance or energy models. Its free plan allows commercial use and limits the number of weather "records" you can retrieve per day, so a long date range costs more than a single forecast.

7. Weatherstack: simple, but a small free tier

Weatherstack has a clean API for current weather, but its free plan includes only 100 calls a month. Paid plans run from $9.99/month (50,000 calls) to $99.99/month (1 million calls). It suits a project that already uses other APILayer services.

8. National Weather Service: free, official, US only

The US National Weather Service API is run by the US government. It's free, has no key and returns GeoJSON. It does ask you to send a User-Agent header that identifies your app. Getting a forecast takes two calls: one to find the forecast grid for a coordinate, then the forecast itself.

import requests

headers = {"User-Agent": "my-weather-app (you@example.com)"}
point = requests.get("https://api.weather.gov/points/38.8894,-77.0352", headers=headers, timeout=10).json()
forecast = requests.get(point["properties"]["forecast"], headers=headers, timeout=10).json()
for period in forecast["properties"]["periods"][:3]:
    print(period["name"], period["temperature"], period["shortForecast"])

Which free weather API should you choose?

Prototype, student project or personal app: Open-Meteo. No key, generous limits.
Commercial app on a budget: WeatherAPI.com's free plan, or OpenWeatherMap with a daily spending cap.
Front-end only (no server): Open-Meteo or WeatherAPI, both CORS-friendly.
Historical data and analytics: Visual Crossing or Open-Meteo's historical API.
US-only: the National Weather Service API.
Legacy Dark Sky code: Pirate Weather.

Weather APIs that need no key at all

Besides Open-Meteo, these keyless weather APIs were online in our latest check: 7Timer!, wttr.in, NASA POWER for solar and agricultural weather data, and RainViewer for radar imagery. See all of them on our list of weather APIs with no API key.

wttr.in is a fun one for terminal tools:

curl "https://wttr.in/London?format=3"

Tips for using any weather API

Cache aggressively. Forecasts update every 10–60 minutes. OpenWeatherMap recommends polling no more than every 10 minutes.
Round coordinates. Rounding to two decimal places (about 1 km) improves your cache hit rate.
Keep keys on the server. Proxy keyed APIs through a server or serverless function, not front-end code.
Plan for outages. Keep a second provider configured. Our weather API rankings update daily, so you can see which ones are up right now.

FAQ

What is the best free weather API?

For non-commercial use, Open-Meteo: no API key and 10,000 calls a day. For a commercial project, WeatherAPI.com's free plan of 100,000 calls a month is the most generous.

Is there a free weather API without an API key?

Yes. Open-Meteo, wttr.in, 7Timer! and the US National Weather Service API all work without a key. 22 of the 47 weather APIs we track need no key.

Is the OpenWeatherMap API still free?

Yes, within limits. One Call API 3.0 includes 1,000 free calls per day, and calls above that are billed. You can set a daily limit in your account to stay free.

Which weather APIs can I call from the browser?

APIs that send CORS headers, including Open-Meteo, WeatherAPI.com, Pirate Weather and wttr.in. 20 of the 47 weather APIs we track support CORS.

What Is a Public API? A Plain-English Guide With 20 Examples You Can Call Today

public apis — Sat, 24 Oct 2026 15:11:37 +0000

A public API is an interface that any developer can use, over the internet, to get data or functionality from someone else's service. You send an HTTP request to a URL, and you get structured data back, usually JSON. Weather forecasts, exchange rates, Pokémon stats and random cat facts are all a single request away.

The word "public" is about who can access it , not about price. Some public APIs are completely open, with no sign-up at all. Others ask you to register for a free API key, and many have paid tiers for heavier use. What they share is that they're published for outside developers, with documentation, instead of being locked inside one company.

This guide explains how public APIs work, the jargon you'll meet (API keys, rate limits, CORS), and finishes with 20 real APIs you can call right now. The examples come from the public-apis list, which our directory tracks and health-checks every day.

How does a public API work?

Almost every public API you'll use is a REST API over HTTPS. The pattern is always the same:

You send an HTTP request (usually GET) to an endpoint , a URL like https://catfact.ninja/fact.
You optionally add parameters (?city=London) and headers (like an API key).
The server replies with a status code (200 means OK) and a body , almost always JSON.

Here's the whole thing in one line of terminal:

curl https://catfact.ninja/fact

{"fact":"An adult lion's roar can be heard up to five miles (eight kilometers) away.","length":75}

That's a public API call. No account, no SDK, no setup.

The same request from JavaScript and Python:

const res = await fetch("https://catfact.ninja/fact");
const { fact } = await res.json();
console.log(fact);

import requests

data = requests.get("https://catfact.ninja/fact", timeout=10).json()
print(data["fact"])

Public vs private vs partner APIs

Type	Who can use it	Example
Public (open) API	Any developer, sometimes after free sign-up	Open-Meteo, PokéAPI, CoinGecko
Partner API	Approved businesses under a contract	Airline booking or banking integrations
Private (internal) API	Only the company's own apps	The API behind a company's mobile app

When people say "public API", they almost always mean the first row: documented, self-serve, and free to start with.

Do public APIs need an API key?

Many don't. Of the 2,166 APIs in our directory, 1,038 need no API key at all. The rest use one of a few schemes:

API key : a long string you get after signing up, sent as a query parameter (?apikey=...) or a header (X-API-Key: ...). This is the most common.
OAuth : used when the API acts on behalf of a user, like posting to their account (GitHub, Spotify, Discord).
User-Agent or contact header : some open services, like OpenStreetMap's Nominatim, ask you to identify your app instead of registering.

Keys exist so providers can count your usage, enforce rate limits and contact you. They're not a sign that an API costs money; most keyed APIs on the list have a free tier. If you're just starting out, browse free APIs with no API key first.

What are rate limits?

A rate limit caps how many requests you can make in a period: per second, minute, day or month. Go over it and you'll get an HTTP 429 Too Many Requests response. Free tiers are where limits matter most. For example, as of October 2026:

Open-Meteo's free, non-commercial API allows 10,000 calls per day.
Alpha Vantage's free key allows 25 requests per day.
ipstack's free plan includes 100 requests per month.

The practical rules: cache responses, don't call an API on every page view, and back off when you see a 429.

What is CORS, and why does it matter?

CORS (Cross-Origin Resource Sharing) decides whether JavaScript running in a browser can call an API on another domain. If the API sends an Access-Control-Allow-Origin header, your front end can call it directly. If not, the browser blocks the response and you'll need to call the API from a server instead.

In our directory, 878 APIs are listed as CORS-enabled. If you're building a front-end-only project, start with free APIs for frontend projects.

Are public APIs safe to use in production?

They can be, with a few precautions:

Prefer HTTPS. 2,078 of the 2,166 APIs we track support it.
Check uptime. Free services come and go. Our daily health check found 1,923 of the 2,166 listed APIs online on October 24, 2026, which means roughly one in nine was unreachable that day.
Read the terms. Several free tiers are "non-commercial only" (Open-Meteo's free endpoint and ip-api.com's free endpoint, for example).
Have a fallback. For anything critical, know which alternative you'd switch to. Every API page in our directory links to its alternatives.

20 public APIs you can call right now

Every URL below returned data in our checks this week, and none of them needs an API key.

API	What it returns	Try it
Cat Facts	A random cat fact	`https://catfact.ninja/fact`
Dogs	A random dog photo URL	`https://dog.ceo/api/breeds/image/random`
PokéAPI	Pokémon data	`https://pokeapi.co/api/v2/pokemon/pikachu`
Open-Meteo	Weather forecasts	`https://api.open-meteo.com/v1/forecast?latitude=51.5&longitude=-0.13&current=temperature_2m`
wttr.in	Weather as JSON or text	`https://wttr.in/London?format=j1`
Frankfurter	Currency exchange rates	`https://api.frankfurter.dev/v1/latest?base=USD&symbols=EUR,GBP`
CoinGecko	Crypto prices	`https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd`
Coinpaprika	Crypto market data	`https://api.coinpaprika.com/v1/tickers/btc-bitcoin`
JSONPlaceholder	Fake posts, users and todos	`https://jsonplaceholder.typicode.com/todos/1`
DummyJSON	Fake products, carts and users	`https://dummyjson.com/products/1`
RandomUser	Random user profiles	`https://randomuser.me/api/`
FakeStoreAPI	E-commerce sample data	`https://fakestoreapi.com/products/1`
Open Trivia	Trivia questions	`https://opentdb.com/api.php?amount=5`
JokeAPI	Jokes, with safe mode	`https://v2.jokeapi.dev/joke/Programming?safe-mode`
Advice Slip	A random piece of advice	`https://api.adviceslip.com/advice`
Agify.io	Predicted age from a first name	`https://api.agify.io/?name=michael`
Open Library	Book search	`https://openlibrary.org/search.json?q=dune`
Zippopotam.us	Postal code lookup	`https://api.zippopotam.us/us/90210`
Spaceflight News	Space news articles	`https://api.spaceflightnewsapi.net/v4/articles/?limit=5`
Httpbin	Echoes your request back	`https://httpbin.org/get`

How to find the right public API

A list of 2,000+ APIs is only useful if you can narrow it down. A quick checklist:

Start from the category. Weather, finance, maps, games: browse by category.
Filter by access. No key for prototypes, CORS for front-end calls, HTTPS for anything real.
Check reliability. Our best API rankings put APIs with strong uptime and fast responses first.
Read the docs and terms before you build on it.

FAQ

Is a public API the same as a free API?

Not always. "Public" means anyone can access it; many public APIs are free or have a free tier, but some charge from the first request. Every API in the public-apis list is free or has a free tier.

What's the difference between an API and an endpoint?

An API is the whole interface a service offers. An endpoint is one URL within it, like /v1/forecast in the Open-Meteo API.

Can I use public APIs in a commercial product?

Often yes, but check the terms. Some free tiers are non-commercial only, and you'll need a paid plan for a commercial product.

Where can I find more public APIs?

Our directory tracks every API in the public-apis GitHub list, the most-starred API list on GitHub, with daily health checks, rankings and developer reviews. Start with the best free APIs by category.