Gemini vs Perplexity for Coding

To build a robust REST API endpoint in Python to accept JSON, validate it, and return error messages, the best tool for the job is FastAPI.

FastAPI uses Pydantic under the hood, which allows you to define validation rules using standard Python data types. It handles the parsing, validation, and error generation automatically.

Here is a step-by-step walkthrough to build a User Registration endpoint.

---

Step 1: Install Dependencies

You will need fastapi (the web framework), uvicorn (the server to run it), and pydantic (for validation). We also install the email extra for email validation.

Run this in your terminal:

pip install fastapi uvicorn "pydantic[email]"

---

Step 2: Define the Data Model and Validation Rules

Create a file named main.py. We will start by defining the exact structure of the JSON payload we expect using a Pydantic BaseModel.

from pydantic import BaseModel, Field, EmailStr, field_validator
import re

class UserRegistration(BaseModel):
    # 1. String validation: required, 3-50 characters
    username: str = Field(..., min_length=3, max_length=50, description="Unique username")
    
    # 2. Email validation: validates standard email formats automatically
    email: EmailStr 
    
    # 3. Integer validation: Optional field, but if provided, must be >= 18
    age: int | None = Field(default=None, ge=18, description="User age (must be at least 18)")
    
    # 4. Custom validation: minimum length of 8, plus custom logic below
    password: str = Field(..., min_length=8)

    # Custom Validator: Ensure password has at least one number and one special character
    @field_validator('password')
    @classmethod
    def validate_password_complexity(cls, value):
        if not re.search(r"\d", value):
            raise ValueError("Password must contain at least one number")
        if not re.search(r"[!@#$%^&*]", value):
            raise ValueError("Password must contain at least one special character (!@#$%^&*)")
        return value

What is happening here?

• Field(...): The ... means the field is required. We also define constraints like min_length and ge (greater than or equal to).
• EmailStr: Automatically checks if the string is a valid email (e.g., user@example.com).
• @field_validator: Allows us to write custom Python logic. If the password doesn't contain a number or special character, we raise a ValueError which FastAPI will parse into a clean JSON error response to the user.

---

Step 3: Create the FastAPI Application and Endpoint

Now, let's add the actual API endpoint to main.py.

from fastapi import FastAPI, HTTPException

app = FastAPI(title="User Registration API")

@app.post("/register", status_code=201)
async def register_user(user_data: UserRegistration):
    """
    Accepts user details, validates them, and registers the user.
    """
    # If the code execution reaches here, the JSON is 100% valid!
    
    # (In a real app, you would hash the password and save to a database here)
    
    # Return a success response (excluding the password for security)
    return {
        "message": "User registered successfully!",
        "user": {
            "username": user_data.username,
            "email": user_data.email,
            "age": user_data.age
        }
    }

What is happening here?

• @app.post("/register"): Defines a POST endpoint.
• user_data: UserRegistration: This is the magic of FastAPI. By type-hinting the parameter with our Pydantic model, FastAPI automatically intercepts the incoming JSON request, validates it against our rules, and injects the parsed data into the user_data variable.

---

Step 4: Run the Server

In your terminal, run the application using Uvicorn:

uvicorn main:app --reload

(The --reload flag automatically restarts the server when you make code changes).

---

Step 5: Test the Endpoint (and see the Error Messages)

FastAPI automatically generates a user-friendly documentation interface. You can test your API by visiting http://127.0.0.1:8000/docs in your browser.

Let's look at how the API responds to different JSON payloads.

Scenario A: Successful Request (Valid JSON)

Payload sent:

{
  "username": "john_doe",
  "email": "john@example.com",
  "age": 25,
  "password": "SecurePassword1!"
}

Response (201 Created):

{
  "message": "User registered successfully!",
  "user": {
    "username": "john_doe",
    "email": "john@example.com",
    "age": 25
  }
}

Scenario B: Validation Failure (Missing field & Bad Email)

FastAPI will return a 422 Unprocessable Entity error with a highly detailed breakdown of every field that failed validation.

Payload sent:

{
  "username": "jo", 
  "email": "not-an-email",
  "age": 15,
  "password": "password"
}

Response (422 Unprocessable Entity):

{
  "detail": [
    {
      "type": "string_too_short",
      "loc": ["body", "username"],
      "msg": "String should have at least 3 characters",
      "input": "jo"
    },
    {
      "type": "value_error",
      "loc": ["body", "email"],
      "msg": "value is not a valid email address",
      "input": "not-an-email"
    },
    {
      "type": "greater_than_equal",
      "loc": ["body", "age"],
      "msg": "Input should be greater than or equal to 18",
      "input": 15
    },
    {
      "type": "value_error",
      "loc": ["body", "password"],
      "msg": "Value error, Password must contain at least one number",
      "input": "password"
    }
  ]
}

Summary

By combining FastAPI and Pydantic:

1. You write zero boilerplate code for parsing JSON.
2. The validation logic is decoupled from your business logic. Your endpoint function (register_user) only runs if the data is already perfect.
3. The client receives highly specific, structured error messages telling them exactly where (loc) and what (msg) they did wrong.

I'll walk you through building a complete REST API endpoint in Python using FastAPI (modern choice with automatic validation) and Pydantic for input validation. This handles JSON payloads, validates fields, and returns clear error messages.

Step 1: Install Dependencies

pip install fastapi uvicorn pydantic[email-validator]

Step 2: Define the Pydantic Model (Validation Schema)

Create models.py with a UserCreate model that enforces data types, constraints, and custom rules:

# models.py
from pydantic import BaseModel, EmailStr, Field, validator
from typing import Optional
from datetime import date

class UserCreate(BaseModel):
    name: str = Field(..., min_length=2, max_length=50)
    email: EmailStr
    age: int = Field(..., ge=13, le=120)  # age between 13-120
    birth_date: Optional[date] = None
    
    @validator('name')
    def name_cannot_be_empty(cls, v):
        if v.strip() == "":
            raise ValueError('Name cannot be empty')
        return v.title()  # Auto-format name
    
    @validator('birth_date')
    def birth_date_not_future(cls, v, values):
        if v and v > date.today():
            raise ValueError('Birth date cannot be in the future')
        return v

class UserResponse(BaseModel):
    id: int
    name: str
    email: str
    age: int
    birth_date: Optional[date] = None

Key validation features:

• Required fields: name, email, age
• Type checking: EmailStr validates email format
• Constraints: min_length, ge (greater than or equal), le (less than or equal)
• Custom validators: Empty name check, future date prevention

Step 3: Create the FastAPI App with Endpoint

Create main.py:

# main.py
from fastapi import FastAPI, HTTPException
from pydantic import ValidationError
from models import UserCreate, UserResponse
from typing import List
import uvicorn
from datetime import date

app = FastAPI(title="User API with Validation", version="1.0.0")

# In-memory storage (use database in production)
users_db = []
next_id = 1

@app.post("/users/", response_model=UserResponse, status_code=201)
async def create_user(user: UserCreate):
    """
    Create a new user with full validation.
    
    Expected JSON payload:
    {
        "name": "john doe",
        "email": "john@example.com", 
        "age": 25,
        "birth_date": "1990-01-01"
    }
    """
    global next_id
    user_dict = user.model_dump()
    user_dict['id'] = next_id
    next_id += 1
    users_db.append(user_dict)
    return user_dict

@app.get("/users/", response_model=List[UserResponse])
async def get_users():
    return users_db

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Step 4: Run the API

uvicorn main:app --reload

Visit http://localhost:8000/docs for automatic interactive docs.

Step 5: Test the Validation (Examples)

✅ Valid Request

curl -X POST "http://localhost:8000/users/" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "John Doe",
    "email": "john@example.com",
    "age": 25,
    "birth_date": "1998-05-15"
  }'

Response: 201 Created with validated user (name auto-capitalized).

❌ Invalid Examples & Error Responses

Missing required field:

curl -X POST "http://localhost:8000/users/" -H "Content-Type: application/json" -d '{"email": "test@test.com"}'

422 Unprocessable Entity
{
  "detail": [    {
      "loc": ["body", "name"],
      "msg": "field required",
      "type": "value_error.missing"
    },
    {
      "loc": ["body", "age"],
      "msg": "field required", 
      "type": "value_error.missing"
    }
  ]
}

Invalid email:

curl -X POST "http://localhost:8000/users/" -H "Content-Type: application/json" -d '{"name": "John", "email": "invalid-email", "age": 25}'

422 Unprocessable Entity
{
  "detail": [    {
      "loc": ["body", "email"],
      "msg": "value is not a valid email address: The email address is not valid.",
      "type": "value_error.email"
    }
  ]
}

Age too young:

curl -X POST "http://localhost:8000/users/" -H "Content-Type: application/json" -d '{"name": "John", "email": "john@test.com", "age": 10}'

422 Unprocessable Entity
{
  "detail": [    {
      "loc": ["body", "age"],
      "msg": "Input should be greater than or equal to 13",
      "type": "value_error.number.not_ge"
    }
  ]
}

Step 6: Alternative with JSON Schema (if no Pydantic)

For plain Flask or manual validation using jsonschema:

# Alternative Flask version
from flask import Flask, request, jsonify
from jsonschema import validate, ValidationError
import jsonschema

app = Flask(__name__)

user_schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string", "minLength": 2},
        "email": {"type": "string", "format": "email"},
        "age": {"type": "number", "minimum": 13, "maximum": 120}
    },
    "required": ["name", "email", "age"],
    "additionalProperties": False
}

@app.route('/users/', methods=['POST'])
def create_user():
    try:
        data = request.get_json()
        validate(instance=data, schema=user_schema)
        return jsonify({"message": "Valid user", "data": data}), 201
    except ValidationError as e:
        return jsonify({"error": str(e.message)}), 422

Why This Implementation Excels

1. Automatic validation via Pydantic - no manual if-statements
2. Detailed error messages with field locations and reasons
3. Type safety and auto-documentation via FastAPI
4. Custom business rules via validators
5. Standard HTTP status codes (201, 422)

Pydantic generates validation errors 10x more detailed than manual checks, making debugging trivial.[2]