DEV Community: Jhaemis-hack

How I Built and Consumed an External API Using FastAPI: A Practical Walkthrough

Jhaemis-hack — Sat, 18 Oct 2025 02:25:13 +0000

The Inspiration

I’ve been experimenting with FastAPI, one of the most modern and performant Python frameworks for building web APIs.

This week, I decided to take it a bit further — not just build an API, but also consume another external API inside my app, add rate limiting, error handling, and a touch of developer love.

So in this post, I’ll walk you through exactly how I built a simple but structured FastAPI app that:

Exposes routes like /, /health, and /me
Consumes an external cat-facts API 🐈
Implements rate limiting using SlowAPI
Handles errors gracefully
Is ready for deployment with Procfile, requirements.txt, and pytest tests

Project Setup

Let’s start from scratch.

1. Create and activate a virtual environment

python -m venv .venv
source .venv/bin/activate  # or on Windows: .venv\Scripts\activate

2. Install dependencies

Your requirements.txt should look like this:

fastapi
slowapi
pydantic_settings
httpx[h2]
uvicorn[standard]
pytest

Then install:

pip install -r requirements.txt

Building the App

Let’s start with our main.py — the heart of the app.

# main.py
from fastapi import FastAPI, Request, Response, Depends
from datetime import datetime, timezone
from fastapi.responses import JSONResponse
from fastapi.middleware.cors import CORSMiddleware
from core.error_handlers import register_error_handlers
from services.http_client import safe_http_request
from core.exceptions import NotFoundException
from slowapi import Limiter
from slowapi.errors import RateLimitExceeded
from slowapi.util import get_remote_address
from functools import lru_cache
from typing_extensions import Annotated
from core import config
from contextlib import asynccontextmanager


@asynccontextmanager
async def lifespan(app: FastAPI):
    print("App starting up...")
    await startup_event()
    yield
    print("App shutting down...")


app = FastAPI(lifespan=lifespan, title="My Profile App")
register_error_handlers(app)


@lru_cache
def get_settings():
    return config.Settings()


async def rate_limit_exceeded_handler(request: Request, exc: RateLimitExceeded):
    return JSONResponse(
        status_code=429,
        content={"success": False, "error": "Too many requests, please slow down."},
    )


limiter = Limiter(key_func=get_remote_address)


async def startup_event():
    app.state.limiter = limiter
    app.add_exception_handler(RateLimitExceeded, rate_limit_exceeded_handler)


app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=False,
    allow_methods=["*"],
    allow_headers=["*"],
)


Profile_details = {
    "email": "gbemilekekenny@gmail.com",
    "name": "James Kehinde",
    "stack": "NodeJs",
}


@app.get("/")
async def home():
    return JSONResponse({
        "success": True,
        "message": "Welcome to my profile API"
    })


@app.get("/health")
async def health_check():
    return JSONResponse({
        "success": True,
        "message": "Ok"
    })


@limiter.limit("8/minute")
@app.get("/me")
async def get_profile(request: Request, settings: Annotated[config.Settings, Depends(get_settings)]):
    url = settings.cat_api_url
    fact = await safe_http_request("GET", url, params={"max_length": 40}, timeout=3000)

    if not fact:
        raise NotFoundException("Timeout, try again later.")

    data = {
        "status": "success",
        "user": Profile_details,
        "timestamp": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
        "fact": fact["fact"]
    }
    return JSONResponse(content=data)


@app.get("/favicon.ico", include_in_schema=False)
async def favicon():
    return Response(status_code=204)

Key Takeaways from the Implementation

1. Rate Limiting

Using slowapi, I restricted requests to /me to 8 per minute per client.

This prevents abuse and adds robustness.

2. External API Consumption

I used an async HTTP client wrapper (httpx) to fetch cat facts from an external API.

The idea was to simulate consuming a third-party service within my API.

3. Error Handling

Custom error handlers are registered in core/error_handlers.py, ensuring consistent JSON responses instead of raw stack traces.

4. Lifespan Events

Instead of deprecated @app.on_event("startup"), I used FastAPI’s lifespan context manager — the modern, recommended approach.

Testing the App with Pytest

To make sure everything works smoothly, I added test_main.py:

from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_home_route():
    response = client.get("/")
    assert response.status_code == 200
    data = response.json()
    assert data["success"] is True

Run tests with:

pytest -v

Running the App Locally

To start your server locally:

uvicorn main:app --reload

Your app will be live at:
👉 http://127.0.0.1:8000

You can visit:

/ → Welcome route
/health → Health check
/me → Profile + external cat fact

🚢 Deployment Ready

If deploying on Render, Railway, or Heroku, your Procfile should look like:

web: uvicorn main:app --host=0.0.0.0 --port=${PORT:-8000}

Wrapping Up

In this small but practical project, I:

Built a clean and modern FastAPI service
Integrated an external API with async HTTP calls
Implemented rate limiting
Structured the app for production and deployment

This project gave me a clearer view of API consumption patterns inside FastAPI, and how easy it is to scale small ideas into something production-ready.

Author

James Kehinde — Full-Stack Developer | Node.js + FastAPI Enthusiast | Building meaningful software from Lagos 🇳🇬

💬 Let’s connect on LinkedIn or Twitter if you’re building something cool with FastAPI!

deciphering The "req" Object in Node.Js

Jhaemis-hack — Mon, 16 Dec 2024 22:12:06 +0000

Have you also been wandering what Exactly does "req" and "res" do in your express application, What are the methods I can utilize with it. Have you also been taunted with the fact that we do not only have req.body, but also req.params... apart from this two, what other methods does it have? Well, you are not alone (...Obviously). In this post, I will be helping you to decipher what exactly "req" and "res" does in your express app, and methods associated with REQUEST object.

The 'req' (request) object in Express JS is used to represent the incoming HTTP request that consists of data like parameters, query strings, request body and so on.

Some Other Usefulness Include:

Accessing the Request Data: By using the req object, we can access the various components of the incoming HTTP request which consists of data, headers, parameters, etc.
Middleware Interaction: middleware functions can change and modify the request object by allowing various tasks of logging and authentication.
Routing: By implementing the dynamic routes in the application, the req object can be used as it captures the URL parameters and also allows it to respond dynamically based on the client's input.

While, on the Other hand, "res" (Response) object is used to send the HTTP response to the client which allows the modification of headers and consists of status codes, and resources.

Few of it's Usefulness include:

Send Responses: The res object is used to send the HTP responses to the client which includes the resource, data, status codes, and headers.
Error Handling: we can send the error responses which is important for handling the errors and providing feedback to the client.
Content Modification: We can also set the custom response headers, status codes, and content through which the response control can be managed by us.

Now, let's Jump to the Main Focus of this post, REQUEST METHODS!

If you have been following along, you should now have a little glimpse of what "req" is and does in your code. Howbeit, the question still stands, are there any other methods apart from req.body and req.params? I will begin to dig that up for you now.

Methods Associated with REQ. Object:
Majorly, there are four methods directly associated with req object. They are:

req.body
req.params
req.query
req.headers

However, there are also some few properties often confused to be part of the unique methods inbuilt with req object. such include:
'req.method', 'req.url', 'req.cookies', 'req.ip', ...

`req.body`:

This method allows us to access all the data sent from the front end to the backend by the client in the body of a POST, PUT, or PATCH request. Hence requires a middleware, like express.json() or bodyParser.json() to parse it.

app.post('/login', (req, res) => {
    console.log(req.body); // Logs user credentials sent in the body
});

req.query:

Stores, as a subsidiary of req.body, query parameters right after ? joined to the URL. Often used for filtering or searching datas.

// URL: /search?name=John
app.get('/search', (req, res) => {
    console.log(req.query.name); // Outputs 'John'
});

req.params:

Holds route parameters defined in the URL paths. It is often indicated by a : symbol. It is typically used for dynamic routes. It will automatically get whatsoever is placed in that position in the URL path.

// URL: /user/123
app.get('/user/:id', (req, res) => {
    console.log(req.params.id); // Outputs '123'
});

req.headers:

this method Contains headers sent by the client, often used for authentication or content negotiation.

app.get('/data', (req, res) => {
    console.log(req.headers['authorization']); // Outputs the auth token
});

I hope you can boast yourself of understanding the functionality of "res" and "req" in your express app now.
Thank you for stopping by.

Async Vs Sync, which is most preferrable?

Jhaemis-hack — Mon, 02 Dec 2024 10:34:36 +0000

According to the description of JavaScript(Js), we have been informed that Js is a single threaded language that enforces blocking programming model which will prevent codes from running haphazardly or randomly(i.e, runs in order from the first line of code to the last line of code).

Hence, in a block of codes JavaScript run the last line of code last.

However, an additional functionality that set JavaScript aside from every other language is the ability of the codes to run in no particular order. A good illustration will be to consider a restaurant ordering system. Let's say we have six(6) customers in the restaurant, and they all ordered for different delicacies.
the first ordered for pounded yam
the second order for white yam
the third ordered for white rice
the fourth, jollof rice
the fifth, beans
and the sixth, jollof spaghetti.

conventionally, the chefs should attend to the first customer, then the second and on and on to the sixth customer. That's the way normal Js works. Until it finishs running the first line of code the second won't run and if the fifth throws an error, it will never read the sixth line of code. However, if you have ever been to a standard restaurant, it just doesn't work that way. Rather than waiting for pounded yam to get served first, other cook in the kitchen will asynchronously start preparing for the other dishes that won't take more time. So it is possible for the sixth customer who requested for jollof spaghetti to get served first.

That is just how the asynchronous property of Js works. If the fourth line of code is set to async, Js will not wait for it before running the fifth and sixth line. Hence, this allows a non-blocking functionality in Js.

There are basically three forms of async model:

async-await
.then .Catch
.finally()

async-await

A modern and clean way to work with promises. It makes asynchronous code look and behave more like synchronous code. await pauses the execution of the function until the promise resolves or rejects.

async function fetchData() {
    try {
        const response = await fetch('https://jsonplaceholder.typicode.
com/posts/1'); // Wait for the fetch to complete
        const data = await response.json(); // Wait for the response to be parsed as JSON
        console.log('Data:', data); // Log the fetched data
    } catch (error) {
        console.error('Error:', error); // Handle any errors
    }
}

fetchData();

Declared an async function.
Allows the use of await inside the function.
Pauses the execution of the function until the promise resolves.
await fetch(...) waits for the HTTP request to complete.
await response.json() waits for the response body to be parsed as JSON.
try...catch handles any errors that occur during the asynchronous operation.
For example, if the network request fails, the error will be caught and logged.

An async function declaration creates an AsyncFunction object. Each time
when an async function is called, it returns a new Promise which will be resolved with the value returned by the async function, or rejected with an exception uncaught within the async function.

Async can also be used as a function.

Async functions can contain zero or more await expressions. Await expressions make promise-returning functions behave as though they're synchronous by suspending execution until the returned promise is fulfilled or rejected. The resolved value of the promise is treated as the return value of the await expression. Use of async and await enables the use of ordinary try/catch blocks around asynchronous code.

async function getProcessedData(url) {
  let v;
  try {
    v = await downloadData(url);
  } catch (e) {
    v = await downloadFallbackData(url);
  }
  return processDataInWorker(v);
}

.then .catch

This shows how .then() is used to chain promise-based operations and handle asynchronous data fetching

fetch('https://jsonplaceholder.typicode.com/posts/1')
    .then(response => {
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        return response.json(); // Parse the response as JSON
    })
    .then(data => {
        console.log('Data:', data); // Log the fetched data
    })
    .catch(error => {
        console.error('Error:', error); // Handle any errors
    });

Initiates an HTTP request to the provided URL.
Returns a promise that resolves to the HTTP response.
If successful, the response is parsed as JSON using response.json(),
Second .then() Block: Handles the parsed JSON data from the first .then().
Logs the data to the console.
catch Block: Handles errors that occur in any of the .then() blocks or during the fetch call.
Logs the error message to the console

.finally()

It ensures that a specific block of code runs no matter what happens in the promise.

fetch('https://jsonplaceholder.typicode.com/posts/1')
    .then(response => {
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        return response.json(); // Parse the response as JSON
    })
    .then(data => {
        console.log('Data:', data); // Log the fetched data
    })
    .catch(error => {
        console.error('Error:', error); // Handle any errors
    })
    .finally(() => {
        console.log('Request completed.'); // Executes regardless of success or failure
    });

The .finally() block is executed after the promise is settled, regardless of whether it was fulfilled or rejected.
It’s useful for cleanup tasks, such as hiding a loading spinner or resetting variables, that should run no matter what.
If the promise is fulfilled: The .then() blocks execute, followed by .finally().
If the promise is rejected: The .catch() block executes, followed by .finally()

Now, you can decide which is best for your project.

Still Don't Understand Loops? Look No Further.

Jhaemis-hack — Tue, 26 Nov 2024 10:11:55 +0000

In this post, I will be addressing all you concerns about what loops are and how they work. Whichever programming language you are currently learning, whether it is Java, Python, JavaScript, C#, c++, e.t.c, they all follow the same nomenclature of action. I intend to help you trash out the concept of Loops on your Journey to becoming a programmer. In this post, I will make use of JavaScript as a reference point to whichever Language you are learning.

What is a Loop?

According to Zuckerberg's Chat Bot(Meta AI): A loop is a control structure in programming that allows a sequence of instructions to be executed repeatedly, either for a fixed number of iterations or until a specific condition is satisfied.

I like this definition as it makes explicit indication - "Until a specific condition is satisfied". To redefine it, Loops are blocks of code that will not stop iterating over and over unless an already declared condition becomes false (i.e, condition is no longer true).

When constructing a loop, a condition of action is always declared and the loop will not be terminated unless the declared condition is no longer true.

There are basically, 2 major types of Loops in all programming languages:

For Loop
While Loop

However, In JavaScript there are 5 forms of Loops:

For Loop
For Of Loop
For In Loop
While Loop
Do While Loop

I will focus on those 2 major ones in this post while also making references to the other forms we have in Javascript.

FOR LOOP

As I have already established, Loops are used for repeatedly running some blocks of code. However, they all have their best used cases. FOR loops are mostly used to iterate over a sequence, such as an array, object, set, or string.

If you want to individually work with all the members of an array or object, For Loop might just be your best choice.

Here is a simple structure of a For Loop

// Define an array

let numbers = [1, 2, 3, 4, 5];

// Use a For loop to iterate over the array

for(let i = 0; i < numbers.length; i++) {

  // Print each number

  console.log(numbers[i]);
}

We define an array numbers containing five integers.
The For loop iterates over the numbers array.
The variable i is the loop counter, initialized to 0.
The loop condition checks if i is less than the length of the numbers array which is 5.
Inside the loop, we print the current value of numbers[i] using console.log()
Immediately i becomes > than numbers.length, it becomes false and terminates the Loop

The same is also the case if it is an arrays of strings. However, when working with arrays of strings, it is most advisable to make use of FOR OF loop.

const myArray = ["lucy", "lumzy", "rex", "apex", "wixy"];

for (const item of myArray) {
    console.log(item);
}

This will print each element of myArray to the console.
the itemis standing as an index representator for all the element in myAarray, beginning from the first to the last

And if it is an Object, it's best to make use of a FOR IN Loop.

const myObject = { a: 1, b: 2, c: 3 };

for (const key in myObject) {
    console.log(`Key: ${key}, Value: ${myObject[key]}`);
}

The for...in loop iterates over the keys of the myObject.
The variable key holds the current key or property (e.g., a, b, c).
The value of the current key is accessed using myObject[key].

In JavaScript, a for...in loop is used to iterate over the keys (or properties) of an object. Reference can also be made to the values using the keys.

Take your time to read through the For Loop below to better understand how it works.

// Define an object

let students = [
  { name: 'John Doe', age: 20, grade: 85 },
  { name: 'Jane Doe', age: 22, grade: 90 },
  { name: 'Bob Smith', age: 21, grade: 78 },
  { name: 'Alice Johnson', age: 20, grade: 92 },
];

// Use a For loop to iterate over the array

for (let i = 0; i < students.length; i++) {
  // Check if the student's grade is above 85 and age is above 21

  if (students[i].grade > 85 && students[i].age > 21) {
    // Print the student's name and grade

    console.log(`${students[i].name} has a grade of ${students[i].grade}`);

  } else if (students[i].grade > 85 && students[i].age <= 21) {
    // Print a message if the student's grade is above 85 but age is 21 or below

    console.log(`${students[i].name} is a high-achieving student, but not yet 22 years old.`);

  } else {
    // Print a message if the student's grade is 85 or below

    console.log(`${students[i].name} needs to improve their grade.`);
  }
}

WHILE LOOP

While loop is less preferred by most programmers due to its unique conditional cases. Unlike For loop, While Loops can both be used with a Boolean and numeric conditional cases.

// Initialize a counter variable

let i = 0;

// Set a condition for the loop

while (i < 5) {

  console.log(`Counter: ${i}`)// Print the current value of the counter

  i++;
}

Using a Boolean test case as conditions allows programmers a lot of unique usage of the Loop.

Here is a simple code block for a while loop:

let count = 0;

while (count < 5) {
    console.log(`Count is: ${count}`);

    count++; // Increment the count
}

The loop continues as long as the value of count is less than 5.
count++; Increases the value of count by 1 on each iteration.
When count reaches 5, the condition count < 5 becomes false, and the loop stops.

However, While loop also works well with a Boolean Conditional case. Here is an example of such:

let isRunning = true;

while (isRunning) {
    console.log("The loop is running...");

    isRunning = false; // Change the condition to stop the loop
}

After the first iteration, isRunning is set to false, so the loop condition is no longer satisfied, and the loop ends.

Similar to While loop is do-While loop. The only difference between the two is that While Loop condition is checked before the loop executes (i.e, the loop body may not run if the condition is false initially - "Check first, then execute"), whilest, Do-While Loop executes at least once before the condition is checked, regardless of whether the condition is true or false.

Here is a simple do-While Loop code:

let count = 0;

do {
    console.log(`Count is: ${count}`);
    count++;
} while (count < 5);

Check up this While loop to better understand how it works in application.

let isLoggedIn = false;

// Simulate user login attempt

while (!isLoggedIn) {

  let username = prompt("Enter your username:");
  let password = prompt("Enter your password:");

  // Verify login credentials 

  if (username === "admin" && password === "password") {
    isLoggedIn = true; //sets the condition true

    console.log("Login successful!");

  } else {

    console.log("Invalid username or password. Please 
try again.");

  }
}

// User is now logged in

console.log("Welcome to the dashboard!");

a boolean variable isLoggedIn is initialized to false.
The While loop checks the condition !isLoggedIn, which is equivalent to (isLoggedIn === false).
If the condition is true, the loop body executes
If the credentials are valid, sets isLoggedIn to true.
Steps 2-3 repeat until the condition !isLoggedIn is false.
Once the condition is false, the loop exits, and the user is logged in.

One common mistake programmers make with WHILE Loops is that they define the condition within the loop, which eventually crashes the terminal.

If you have followed me through up to this point, congratulations you have just divulged the most important points you need to know before effectively using a Loop.