From Zero to API Hero: Building Real Apps in One YouTube Session

"Who here has actually called an API in Python?"

Silence. A few hesitant hands in the chat. "I've heard of APIs but never used one," someone typed. "Seems complicated," added another.

That's exactly why I decided to host this live session on YouTube – to demystify something that sounds technical but is actually beautifully simple once you see it in action.

By the end of that session, students weren't just understanding APIs – they were building working applications. A weather app. A joke generator. A random dog image viewer. All functional. All built from scratch in under an hour.

The comment that made my day? "I can't believe I just built something that actually works. This is incredible!"

Let me take you through exactly what happened – and how you can do the same.

What Even Is an API? (The Non-Boring Explanation)

Before writing a single line of code, I needed to clear up the confusion. API stands for Application Programming Interface, but that definition helps nobody.

Here's how I explained it during the live session:

Think of an API like a waiter in a restaurant.

You (the customer) don't go into the kitchen and cook your own food. You tell the waiter what you want. The waiter takes your order to the kitchen, the kitchen prepares it, and the waiter brings it back to you.

An API works the same way:

• You (your Python code) want some data
• The API is the waiter that takes your request
• The server (someone else's computer) processes it
• The API brings back the data you requested

That's it. That's literally what we're doing when we "call an API."

Someone in the chat wrote: "Okay, that actually makes sense now!"

Perfect. Let's build something.

Setting Up: The Two Libraries You Need

Live on screen, I showed the installation process. No assumptions. No "you should already know this." Just practical, step-by-step setup.

pip install requests
pip install streamlit

Requests – This library lets Python talk to APIs (send requests, receive responses)

Streamlit – This turns your Python script into a beautiful web app in seconds

Both installed in under a minute. Now we're ready.

Project #1: Building a Live Weather App

This was the main demonstration – building a fully functional weather app that anyone could use.
The Concept
I explained: "We're going to use OpenWeatherMap's API. You type in a city name, hit a button, and get the current temperature. Simple, clean, functional."
The Code (Written Live)
I opened VS Code on screen and started typing, explaining each line as I went:

import requests
import streamlit as st
st.title("Weather App")
city = st.text_input("Enter city name: ")
api = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid=YOUR_API_KEY"
if st.button("Get"):
    response = requests.get(api)
    if response.status_code == 200:
        weather_data = response.json()
        st.write(f"Temperature: {weather_data['main']['temp']} K")

Line by line, here's what's happening:

1. Import libraries – We bring in our tools
2. Create a title – st.title() gives our app a heading
3. Get user input – st.text_input() creates a text box where users type the city name
4. Build the API URL – We insert the city name into the API endpoint
5. Make the request – When the button is clicked, requests.get() calls the API
6. Check the response – Status code 200 means success
7. Parse the data – .json() converts the response into Python-friendly format
8. Display the result – Show the temperature on screen

Running It Live
The magic moment. I ran the command:
streamlit run weather_app.py
A browser window opened. There was our app – a clean interface with a text box and a button.
I typed "Mumbai" and clicked "Get."
Temperature appeared on screen: 302.15 K
The chat exploded with excitement. "Wait, that's it?!" "We just built a working app!" "This is so cool!"

The Learning Philosophy I Emphasized

At this point in the session, I paused to make something clear:
This isn't about memorizing code. This is about understanding the pattern.
Every API call follows the same basic structure:

1. Import the requests library
2. Define your API endpoint (URL)
3. Make the request (requests.get())
4. Check if it worked (status_code)
5. Extract the data (.json())
6. Use the data however you want

Once you understand this pattern, you can call any API in the world.

The Treasure Trove: 9 Free APIs to Practice With

After the weather app demo, I shared my curated list of free, beginner-friendly APIs. These require no payment, minimal setup, and are perfect for practice projects.
1. Joke APIs – For Fun Learning
Official Joke API

• URL: https://official-joke-api.appspot.com/jokes/programming/random
• No API key needed
• Returns programming jokes in JSON format

Example response:
{  "setup": "Why do programmers prefer dark mode?",
  "punchline": "Because light attracts bugs."
}
I showed how you could build a "Random Programming Joke Generator" in under 10 minutes using the exact same pattern we used for weather.
2. Movie & TV Show APIs – For Entertainment Projects
OMDb API (Open Movie Database)

• Get movie details, IMDb ratings, plot summaries
• Free API key available
• Perfect for building movie search apps

TVMaze API

• Search TV shows, get cast information, episode schedules
• No API key required
• Great for "Find Your Favorite TV Show" projects

One student immediately said: "I'm building a movie recommendation app for my project. This is perfect!"
3. Quotes API – For Daily Inspiration Apps
Quotable API

• URL: https://api.quotable.io/random
• Returns random inspirational quotes
• No authentication needed

Perfect for building a "Quote of the Day" app or adding motivational content to your projects.
4. Anime & Manga APIs – For the Otakus
Jikan API (Unofficial MyAnimeList API)

• Search anime by name
• Get ratings, episodes, character info
• Completely free and well-documented

The anime fans in the chat went wild over this one.
5. Music API – For Lyrics Lovers
Lyrics.ovh API

• URL format: https://api.lyrics.ovh/v1/Coldplay/Adventure of a Lifetime
• Get song lyrics by artist and song name
• No API key required

"I could build a lyrics finder app!" someone exclaimed in the comments.

Exactly. That's the point.
6. Trivia & Quiz APIs – For Interactive Learning
Open Trivia Database

• URL: https://opentdb.com/api.php?amount=10
• Get quiz questions with multiple difficulty levels
• Customize by category (science, history, movies, etc.)

Perfect for building quiz applications or study tools.
7. Image APIs – For Visual Projects
Pexels & Unsplash APIs

• Free stock photos and videos
• Requires free API key
• Great for building wallpaper apps or image galleries

8. Cat & Dog Image APIs – For Pure Joy
The Cat API & Dog CEO's Dog API

• Random cute animal pictures
• Minimal or no authentication
• Perfect first API project

Example response from Dog API:
{
  "message": "https://images.dog.ceo/breeds/hound-afghan/n02088094_1003.jpg",
  "status": "success"
}

Someone commented: "I'm definitely building a 'Random Dog of the Day' app now!"
9. Meme API – For Social Media Projects
Meme API

• URL: https://meme-api.com/gimme
• Random memes from Reddit
• No API key needed

The Challenge I Gave Everyone

Near the end of the session, I issued a clear challenge:

"Pick ONE API from this list. Build ONE simple app with it. Just one. This week."

Don't try to do everything. Don't overcomplicate it. Pick something that genuinely interests you:

• Love movies? Build a movie search app.
• Into jokes? Create a joke generator.
• Animal lover? Make a random pet picture viewer.
• Want daily motivation? Build a quote app.

Start with the pattern I showed. Modify it for your chosen API. See it work. Feel the satisfaction of building something real.

The Pattern That Works Every Time

Throughout the session, I kept reinforcing this universal pattern:

import requests
import streamlit as st
# 1. Create your interface
st.title("Your App Name")
user_input = st.text_input("What do you want?")
# 2. Build your API URL
api_url = f"https://api.example.com/endpoint?query={user_input}&key=YOUR_KEY"
# 3. Make the request when button clicked
if st.button("Get Data"):
    response = requests.get(api_url)
    # 4. Check if successful
    if response.status_code == 200:
        data = response.json()
        # 5. Display the data
        st.write(data)

This pattern works for 90% of APIs. Once you master this, you can integrate almost any external data source into your Python projects.

Why This Matters for Data Science Students

Several students asked: "But we're learning data science. Why do we need APIs?"

Great question. Here's why:

Real-world data doesn't come from CSV files.

In actual data science work, you'll:

• Pull financial data from trading APIs
• Collect social media data from Twitter/Reddit APIs
• Fetch real-time sensor data from IoT APIs
• Access weather data for climate models
• Get demographic data from government APIs

Knowing how to call APIs isn't a side skill. It's fundamental to modern data work.

Plus, every API call is just data collection. And what do data scientists do? Work with data. This is how you get it.

Common Mistakes I Addressed Live

During the session, I made sure to cover the typical pitfalls:
1. Status Code Confusion
"Always check response.status_code before trying to use the data. 200 = success. Anything else = something went wrong."
2. JSON Parsing Errors
"Use .json() to convert the response into a Python dictionary. Then you can access data like data['main']['temp']"
3. API Key Management
"Never hardcode API keys in code you share publicly. Use environment variables or config files."
4. Reading Documentation
"Every API is slightly different. Always check the documentation. It tells you exactly what parameters to send and what data you'll get back."

The Practical Homework

I ended the session with specific, actionable next steps:

Week 1:

• Install requests and streamlit
• Run the weather app code
• Modify it to show humidity or wind speed instead of just temperature

Week 2:

• Pick one API from the list
• Build a simple app using that API
• Share your project in the comments

Week 3:

• Combine two APIs in one app
• Example: Show weather AND a random motivational quote
• Or: Display a random dog picture with a joke

Start simple. Build complexity gradually. Celebrate small wins.

Why I Love Teaching This Topic

As a Subject Matter Expert at Red & White Skill Education, I've taught countless technical topics. But API calling sessions are special.

Why? Because the transformation is immediate and visible.

Students go from "I don't understand APIs" to "Look, I built this!" in under an hour. That's powerful. That's the moment learning clicks.

APIs bridge the gap between theoretical coding knowledge and practical application building. Once students realize they can pull data from anywhere in the world with a few lines of code, their entire perspective shifts.

Suddenly, they're not just writing Python exercises. They're building tools. Creating applications. Solving real problems.

That's what education should feel like.

The Resources I Shared

During the session, I made sure everyone had access to:

📄 Complete lecture notes: http://bit.ly/4bLtn2x

🐍 Python download: Official Python website

💻 VS Code download: Free code editor

📚 Full API list: All 9 APIs with documentation links in the notes

Everything you need to continue learning after the session ends.

What Students Built Afterward

The best part? Seeing what students created after the session.

Comments and messages poured in:

• "Built a random joke app for my college project!"
• "Created a daily motivation quote app that I use every morning"
• "Made a movie search tool – my friends love it"
• "Combined weather + quote API – shows weather with motivational message"

Some even went beyond what I taught:

• One student built a Telegram bot using the Joke API
• Another created a trivia quiz game with score tracking
• Someone made an anime search engine with image display

That's the power of understanding the fundamentals. Once you know the pattern, the possibilities are endless.

Looking Forward

This API calling session is just one piece of the puzzle. APIs are your gateway to:

• Building full-stack applications
• Creating data pipelines
• Developing machine learning projects that use live data
• Making portfolio projects that actually impress recruiters

In upcoming sessions, we'll explore:

• Authentication and API keys in depth
• POST requests (sending data, not just receiving)
• Handling errors and rate limits
• Building complex, multi-API applications
• Deploying your apps so others can use them

But it all starts here. With understanding how to call an API. With building that first simple app.

My Final Thought

If you take away just one thing from this session, let it be this:

You don't need to be an expert to start building.

You need to understand the basics, follow the pattern, and have the courage to try. The weather app we built? Less than 15 lines of code. The joy of seeing it work? Priceless.

Every major application you use daily – Instagram, Uber, Swiggy, WhatsApp – they're all making API calls constantly. Now you know how to do the same thing.

That text you see? API call. That weather update? API call. That restaurant list? API call.

You're not learning some abstract concept. You're learning the fundamental mechanism that powers modern applications.

So go ahead. Pick an API. Write that first requests.get(). See the data come back. Feel that rush of "I built something real."

That's where every great developer's journey begins.

📺 Full Session Recording: Watch the complete API calling tutorial here

📄 Download Complete Notes: http://bit.ly/4bLtn2x

🔧 Tools You'll Need:

• Python (latest version)
• VS Code
• Requests library: pip install requests
• Streamlit: pip install streamlit

Er. Milan Kathiriya is a Subject Matter Expert at Red & White Skill Education, specializing in Python, Data Science, and practical application development. He conducts live training sessions focused on hands-on learning, helping students build real projects that strengthen their portfolios and confidence.

Subscribe to the channel for more practical coding sessions. Next week: Building a complete quiz application with database integration!

Your Turn: Which API are you most excited to try? Share in the comments below. And when you build your first app, tag me – I'd love to see what you create!

Remember: The best way to learn coding isn't by watching. It's by doing. So open VS Code, pick an API, and start building. I'll be here in the comments to help if you get stuck.