Look, I’m just going to admit it upfront: I have a side project problem.
Not the “I start ambitious projects and never finish them” problem—though yeah, that too. I mean the deeper issue where I can’t stop looking for new project ideas even though I already have twelve unfinished ones sitting in my ~/Code folder judging me.
Last Tuesday made it worse.
Someone on Twitter posted a link to a GitHub repo called public-apis/public-apis. “Free APIs for developers,” the tweet said. Seemed harmless. Click. Scroll. Oh, there’s a NASA API. Cool. Wait, there’s an ISS tracker? Hold on, someone made an API that rates whether a number is interesting or boring?
Fast forward six hours: I’ve started prototyping three apps I’ll never ship, learned more about the Bored API than any human should, and discovered that yes, there is an endpoint that tells you what’s on the Chipotle menu.
This repo is a productivity black hole disguised as a helpful resource. Let me show you why.
What Is This Chaos?
The public-apis/public-apis repository is a community-curated list of free, public APIs you can use without signing your life away to enterprise sales. No “contact us for a demo.” No credit card wall. Just JSON endpoints you can hit with fetch() and start building immediately.
The categories are absurd and wonderful:
- Animals (random dogs, cats, and axolotls—yes, really)
- Space (NASA, asteroids, the ISS)
- Finance (crypto, stocks, forex)
- Food & Drink (cocktails, coffee, brewery data)
- Games (Pokémon, Magic: The Gathering, trivia)
- Literally anything else you can imagine
I’m not kidding when I say I found an API called Numbers API that will tell you fun facts about any number. Hit /42/math and it tells you why 42 is mathematically interesting. This is the kind of delightful nonsense the internet was built for.
The 10 APIs That Wrecked My To-Do List
Most “awesome API” lists are boring corporate garbage. “Here’s Stripe. Here’s Twilio. Here’s another weather service.” These are different. These are weird in the way that makes you think “I could build something with this right now.”
1. NASA APOD – Fetching Data From Literal Space
What it does: Returns the Astronomy Picture of the Day, complete with HD images and descriptions written by actual astrophysicists.
What I built (in 20 minutes):
A browser extension that changes my wallpaper to the APOD every morning. Now I wake up to galaxies instead of my cluttered desktop. It feels like living in the future.
fetch('https://api.nasa.gov/planetary/apod?api_key=DEMO_KEY')
.then(res => res.json())
.then(data => {
console.log(`Today: ${data.title}`);
console.log(`Image: ${data.url}`);
});I tested this. It works. You are 30 seconds away from pulling images from NASA’s archive. The barrier to entry for “cool space project” is now basically zero.
Why this matters: Most tutorials teach you to build a to-do app. Fetching data about supernovas is objectively cooler and teaches you the exact same HTTP concepts.
2. Bored API – For When Procrastination Needs Structure
What it does: Suggests a random activity when you’re bored. That’s it. That’s the whole API.
Sample response:
{
"activity": "Learn a new recipe",
"type": "cooking",
"participants": 1,
"price": 0.1
}What I should build:
A “Productivity Roulette” button on my desktop. When I catch myself mindlessly scrolling Twitter at 2pm, I hit the button, and it forces me to do literally anything else. Learn Rust? Bake bread? Take a walk? Sure. Better than doom-scrolling.
Why it’s brilliant: It’s stateless. No database, no user accounts, no auth. Just pure chaos as a service.
3. Random User Generator – The End of “John Doe”
What it does: Generates fake but realistic user profiles—names, photos, emails, addresses, everything.
Why this saved my life:
Every time I build a UI mockup, I populate it with “John Doe” and “user@example.com” like a Neanderthal. This API gives me real-looking people with actual profile pictures. My designs instantly look 10x more professional.
fetch('https://randomuser.me/api/')
.then(res => res.json())
.then(data => {
const user = data.results[0];
console.log(`${user.name.first} ${user.name.last}`);
console.log(user.picture.large);
});Bonus superpower: It supports “seeding.” Pass the same seed value, get the same fake person every time. Perfect for reproducible test data.
4. Open Notify – Spy on the Space Station
What it does: Tells you exactly where the International Space Station is right this second.
The magic:
You can calculate when it’ll fly over your exact location. Imagine building an app that sends you a push notification: “Look up. ISS passing overhead in 3 minutes.”
That’s not a side project. That’s connecting code to a physical object traveling 17,000 mph in orbit. That’s magic.
fetch('http://api.open-notify.org/iss-now.json')
.then(res => res.json())
.then(data => {
console.log(`ISS is at: ${data.iss_position.latitude}, ${data.iss_position.longitude}`);
});Project idea: Pair this with geolocation. Build a “Look Up!” alert system. You’re now officially a space nerd.
5. PokeAPI – The Platonic Ideal of REST
What it does: Every single Pokémon, move, ability, and stat. Perfectly structured. Zero authentication required.
Why it’s everywhere:
Because it’s the textbook example of how a REST API should work. Clean, predictable, well-documented, and it never goes down.
What everyone builds: A Pokédex clone.
What you should build instead: A “Who’s That Pokémon?” game. Show a silhouette (CSS filter: brightness(0)), let the user guess, reveal the answer. Bonus points for the iconic sound effect.
6. CoinGecko – Crypto Data Without the Gatekeeping
What it does: Real-time prices for 10,000+ cryptocurrencies.
What’s insane: No API key required for the basic tier. Most crypto APIs treat their data like state secrets. CoinGecko just… hands it to you.
fetch('https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd')
.then(res => res.json())
.then(data => console.log(`BTC: $${data.bitcoin.usd}`));Project idea: Build a “FOMO Calculator.” User inputs what they didn’t invest in 2015. App calculates their alternate-universe net worth. Watch them cry.
(I’m half-joking. But also this would absolutely go viral on Twitter.)
7. The Dog API – Pure Joy as JSON
What it does: Returns a random dog picture.
That’s it. That’s the entire API.
And yet, I guarantee you’re going to click this link just to see a random dog. Go ahead. I’ll wait.
See? You clicked it. Everyone clicks it. That’s the power of dogs.
Project idea: Replace every broken <img> on your site with a random dog. Your 404 page is now delightful instead of depressing.
8. Open Library – Books Without Amazon
What it does: Millions of book records from the Internet Archive. Covers, authors, ISBNs, everything.
What I’m building:
A “virtual bookshelf” widget for my personal site. I paste an ISBN, it auto-fetches the cover art and title. My reading list now looks like an actual bookshelf instead of a bulleted list.
fetch('https://openlibrary.org/isbn/9780140328721.json')
.then(res => res.json())
.then(book => console.log(book.title));Why it’s cool: The data structure is deep. You can traverse from Author → Works → Editions → Covers. This is how you learn to navigate complex JSON trees.
9. Alpha Vantage – Wall Street Data for Weekend Projects
What it does: Real-time and historical stock/crypto data.
The catch: Free tier limits you to 5 requests per minute. But for a side project? That’s plenty.
Project idea: A “What If?” calculator. “If I’d bought $1000 of Tesla in 2019, what would it be worth today?”
The answer will hurt. But you’ll learn error handling and date manipulation in JavaScript. Silver lining.
10. World Bank Data – For When You Want to Feel Smart
What it does: Global development indicators. GDP, literacy rates, healthcare stats, etc.
Why I care:
Because I want to build an interactive map showing global inequality over the last 50 years. Not because I’m virtuous—because D3.js makes pretty charts and I need an excuse to learn it.
The hidden value: The data is massive. Pagination, caching, normalization—all the senior-level skills hidden in a “free dataset.”
The Wrapper Business Model (aka How People Make Money With This)
Here’s a secret that’ll make you rethink half the apps on your phone:
Most successful “data apps” are just pretty UIs around free APIs.
Examples:
- Weather apps? Wrapping OpenWeatherMap or Dark Sky.
- Crypto trackers? Wrapping CoinGecko or Binance.
- Flight deal alerts? Scraping or wrapping travel APIs.
The data is free. The value is in making it convenient.
Real examples I’ve seen:
- A surfer app that pings weather APIs hourly and only alerts you when swell > 6ft and wind < 10mph. Monthly subscription: $4.99.
- An iPad app for kids that shows NASA’s picture of the day with a voiceover. One-time purchase: $2.99.
- A Chrome extension tracking the ISS that buzzes when it’s overhead. Freemium with $1.99/month pro tier.
None of these required a CS degree. Just a free API and a weekend.
The Fine Print Nobody Tells You
“Free” APIs aren’t actually free. They cost you in other ways.
1. Rate Limits Are Real (and Brutal)
Most free tiers cap you at 50-100 requests per hour. If your React app fetches on every re-render (classic rookie mistake), you’ll burn through your quota in 90 seconds.
The fix: Cache everything. Use localStorage, sessionStorage, or React Query. Fetch once, display forever.
2. CORS Will Ruin Your Afternoon
Some APIs block browser requests for “security reasons.” You’ll see this error and want to flip your desk:
Access to fetch at 'https://...' has been blocked by CORS policyThe fix: Use a proxy. Either a public one (cors-anywhere) or build your own with a single Next.js API route. Never expose API keys client-side if the API wasn’t designed for it.
3. They Will Go Down (Usually on Weekends)
Public APIs are maintained by volunteers or tiny teams. They’re not AWS with 99.99% uptime SLAs. They’re passion projects held together with hope and duct tape.
The fix: Handle errors like your app depends on it (because it does). Show cached data. Display friendly error states. Never let your entire UI explode because someone’s free API went offline.
The 5-Second Test (Do It Right Now)
Stop reading. Open your browser console (F12). Paste this:
fetch('https://api.nasa.gov/planetary/apod?api_key=DEMO_KEY')
.then(res => res.json())
.then(data => console.log(`Today's space pic: ${data.title}`));Hit Enter.
You just fetched data from NASA. Took you five seconds.
Now imagine wrapping that in 50 lines of HTML. Add a button. Maybe a random fact generator. Boom—you have a deployable product.
The Real Lesson (That Nobody Admits)
Most developer advice is “just build more projects.” But nobody tells you what to build. You end up paralyzed, waiting for the perfect idea that never comes.
The public-apis repo solves this by giving you a menu of chaos. Scroll until something ridiculous catches your eye (medieval fantasy name generator? sure!), then build the dumbest, smallest thing you can think of with it.
Because here’s the secret: Getting good at building isn’t about finding the perfect idea. It’s about shipping 100 imperfect things until the process becomes muscle memory.
The barrier to “interesting project” used to be data. Now the data is sitting there, waiting for you to do something weird with it.
Stop waiting for inspiration. Just pick an API and start typing.
The repo: github.com/public-apis/public-apis
Fair warning: Clicking this link will derail your entire weekend. Your side project list will triple. You’ll start six things and finish zero.
My apology in advance: To your productivity, your sleep schedule, and that other project you swore you’d finish this month.
But hey, at least you’ll learn something. And maybe, just maybe, you’ll actually ship one of them.
(Narrator: He did not ship any of them.)