Skip to main content

Adding Internationalization (i18n) in FastAPI

🌍 Adding Internationalization (i18n) in FastAPI

If you're building a multi-lingual API with FastAPI, it's essential to support internationalization. In this guide, we'll use the python-i18n library — a simple and effective tool for managing translations in Python using JSON files.

πŸ“¦ Step 1: Install python-i18n

pip install python-i18n

πŸ“ Step 2: Create Locale Files

Create a locales directory and add your language JSON files:

locales/
├── en.json
└── fr.json

en.json:

{
  "greeting": "Hello"
}

fr.json:

{
  "greeting": "Bonjour"
}

⚙️ Step 3: Configure i18n in FastAPI

import i18n
from fastapi import FastAPI, Request

app = FastAPI()

# Load translation files
i18n.load_path.append('locales')
i18n.set('fallback', 'en')

🌐 Step 4: Detect Language from Request

@app.middleware("http")
async def add_language_to_request(request: Request, call_next):
    lang = request.headers.get("Accept-Language", "en").split(",")[0]
    i18n.set("locale", lang)
    response = await call_next(request)
    return response

πŸ“¨ Step 5: Use Translations in Your API

from fastapi.responses import JSONResponse

@app.get("/greet")
async def greet():
    message = i18n.t("greeting")
    return JSONResponse(content={"message": message})

πŸ”— Resources

πŸŽ‰ Conclusion

With just a few steps, you've added internationalization support to your FastAPI application! Using python-i18n, you can easily expand your app to support more languages and provide localized content.

Comments

Popular posts from this blog

Mindset — Coin-Size Summary

  Theme: Your beliefs about ability shape your success. Two Mindsets: Fixed Mindset: “I’m either good at this or I’m not.” Growth Mindset: “I can improve with effort and learning.” Key Message: Talent matters, but belief in learning and persistence matters more. Applications: Work: View challenges as growth opportunities. Product: Embrace feedback and iteration. Life: Progress comes from effort, not perfection. Core Lesson: “Becoming is better than being.”

Rethinking Writing Assistants: A Fresh Opportunity in macOS Productivity

In a world full of grammar checkers, writing enhancers, and AI-powered editors, one question remains surprisingly unanswered: why hasn’t anyone built a truly seamless, intelligent writing assistant for macOS that combines next-word prediction with real-time rewriting? The Current Landscape Today’s macOS users have several writing tools to choose from: Compose for macOS: Offers shortcut-activated rewriting, grammar correction, and text shortening in any app. However, it doesn’t predict your next word or sentence. Apple Writing Tools (macOS Sequoia): System-level rewriting, tone adjustment, and proofreading. Great polish, but still reactive rather than proactive. Fixkey: Adds voice-to-text and real-time rewriting with support for multiple languages. GrammarPaw: Lightweight and powerful, with ChatGPT integration, but requires manual activation for each rewrite. Cotypist: Possibly the closest to predictive text—offers GitHub Copilot-style autocomplete across macOS apps, but lacks grammar...

Idempotent Database Operations

In databases, an idempotent operation is one that, when repeated, produces the same result as a single execution. A common idempotent pattern is the UPSERT (update-or-insert) operation. For example, running INSERT … ON CONFLICT UPDATE with the same values multiple times will not create duplicates – it either inserts a new row or updates the existing row, but repeating it makes no further change. In contrast, a naΓ―ve INSERT statement without conflict handling will create duplicate rows on each execution, which is non-idempotent. Similarly, UPDATE queries that set a field to a fixed value (e.g. SET status = 'active') are idempotent: once the value is set, running the update again has no new effect. Deleting a row by its primary key is idempotent as well – after the first delete, further deletes simply find nothing to remove. Database constraints and keys also help: for instance, a unique constraint can silently ignore or reject duplicate inserts. Transactions contribute by making...