String validation (min, max, regex) in FastAPI - Step-by-Step Execution

Concept Flow - String validation (min, max, regex)

Define Pydantic Model with String Field

↓

Add min_length, max_length, regex Constraints

↓

Receive Input Data in FastAPI Endpoint

↓

Validate Input Against Constraints

↓

Process Request

Input string is checked against minimum length, maximum length, and regex pattern before processing or error response.

Execution Sample

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel, constr

class User(BaseModel):
    username: constr(min_length=3, max_length=10, regex='^[a-zA-Z0-9_]+$')

app = FastAPI()

Defines a FastAPI model with a username string that must be 3-10 characters and match a regex pattern.

Execution Table

Step	Input username	Check min_length >=3	Check max_length <=10	Check regex match	Validation Result
1	"ab"	False (length 2 < 3)	Skipped	Skipped	Invalid - too short
2	"abc"	True (length 3 >= 3)	True (length 3 <= 10)	True (matches)	Valid
3	"abcdefghijk"	True (length 11 >= 3)	False (length 11 > 10)	Skipped	Invalid - too long
4	"abc!def"	True (length 7 >= 3)	True (length 7 <= 10)	False (contains '!')	Invalid - regex mismatch
5	"user_123"	True (length 8 >= 3)	True (length 8 <= 10)	True (matches)	Valid

💡 Validation stops at first failed check or passes if all checks succeed.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5
username	None	"ab"	"abc"	"abcdefghijk"	"abc!def"	"user_123"
min_length_check	N/A	False	True	True	True	True
max_length_check	N/A	Skipped	True	False	True	True
regex_check	N/A	Skipped	True	Skipped	False	True
validation_result	N/A	Invalid	Valid	Invalid	Invalid	Valid

Key Moments - 3 Insights

Why does validation stop after the min_length check fails?

Because the execution_table shows that once min_length is false (step 1), max_length and regex checks are skipped, so validation stops early to save time.

What happens if the input is too long but matches regex?

At step 3, max_length check fails even though regex matches, so validation returns invalid due to length, as shown in the execution_table.

Why is regex check skipped when min_length or max_length fails?

Validation stops at the first failure to avoid unnecessary checks, so regex is only checked if length constraints pass, as seen in steps 1 and 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the validation result at step 4 for input "abc!def"?

A Invalid - regex mismatch

B Invalid - too short

C Valid

D Invalid - too long

💡 Hint

Check the regex match column at step 4 in the execution_table.

At which step does the max_length check fail?

A Step 1

B Step 5

C Step 3

D Step 2

💡 Hint

Look at the max_length check column in the execution_table.

If the input "user!name" is tested, which validation check will fail first?

A max_length

B regex

C min_length

D None, it will be valid

💡 Hint

Refer to regex check behavior in the execution_table and variable_tracker.

Concept Snapshot

Use Pydantic's constr type to validate strings in FastAPI.
Set min_length and max_length to limit length.
Use regex to enforce pattern rules.
Validation stops at first failure.
Invalid input returns error response automatically.

Full Transcript

This visual execution shows how FastAPI uses Pydantic to validate string inputs with minimum length, maximum length, and regex pattern constraints. The flow starts by defining a model with these rules. When input arrives, it checks min_length first, then max_length, then regex. If any check fails, validation stops and returns an error. If all pass, the input is accepted. The execution table traces five example inputs step-by-step, showing which checks pass or fail and the final validation result. The variable tracker records how each variable changes after each input. Key moments clarify why validation stops early and how regex is only checked if length is valid. The quiz tests understanding of these steps. The snapshot summarizes how to use constr for string validation in FastAPI.

Practice

1. What does the constr function in FastAPI's Pydantic models help you do?

easy

A. Validate string fields with rules like minimum length, maximum length, and regex patterns

B. Create integer fields with range validation

C. Automatically generate API documentation

D. Handle database connections

Solution

1. Step 1: Understand constr purpose

   constr is a Pydantic type used to validate string fields with constraints like length and regex.

2. Step 2: Compare options

   Only Validate string fields with rules like minimum length, maximum length, and regex patterns correctly describes constr usage for string validation.

3. Final Answer:

   Validate string fields with rules like minimum length, maximum length, and regex patterns -> Option A

4. Quick Check:

   constr = string validation [OK]

Hint: Remember constr is for string validation rules [OK]

Common Mistakes:

• Confusing constr with integer validation
• Thinking constr manages database or docs
• Assuming constr auto-generates API docs

2. Which of the following is the correct way to define a string field in a Pydantic model with minimum length 3 and maximum length 10?

easy

A. name: str(min_length=3, max_length=10)

B. name: constr(min=3, max=10)

C. name: constr(min_length=3, max_length=10)

D. name: str(min=3, max=10)

Solution

1. Step 1: Recall correct syntax for constr

   The correct parameters are min_length and max_length inside constr().

2. Step 2: Check options

   Only name: constr(min_length=3, max_length=10) uses constr(min_length=3, max_length=10) correctly. Options A, B, and D use wrong parameter names or types.

3. Final Answer:

   name: constr(min_length=3, max_length=10) -> Option C

4. Quick Check:

   Use min_length and max_length in constr [OK]

Hint: Use min_length and max_length, not min or max [OK]

Common Mistakes:

• Using min and max instead of min_length and max_length
• Trying to add length constraints directly to str type
• Mixing parameter names

3. Given this Pydantic model snippet:

from pydantic import BaseModel, constr

class User(BaseModel):
    username: constr(min_length=4, max_length=8, regex=r'^[a-zA-Z]+$')

What happens if you try to create User(username='abc123')?

medium

A. Validation error because username is too long

B. User instance created successfully

C. Validation error because username is too short

D. Validation error because username contains digits

Solution

1. Step 1: Analyze regex pattern

   The regex r'^[a-zA-Z]+$' allows only letters, no digits.

2. Step 2: Check input username

   Input 'abc123' contains digits '123', violating the regex.

3. Final Answer:

   Validation error because username contains digits -> Option D

4. Quick Check:

   Regex restricts digits, so error occurs [OK]

Hint: Regex restricts characters; digits cause validation error [OK]

Common Mistakes:

• Ignoring regex and only checking length
• Assuming digits are allowed by regex
• Confusing length errors with pattern errors

4. Identify the error in this FastAPI Pydantic model field:

from pydantic import BaseModel, constr

class Item(BaseModel):
    code: constr(min_length=5, max=10)

medium

A. code field must be an int, not constr

B. max should be max_length to specify maximum string length

C. constr cannot be used for string validation

D. min_length should be min to specify minimum length

Solution

1. Step 1: Check parameter names in constr

   The correct parameter for maximum length is max_length, not max.

2. Step 2: Identify error in code

   Using max=10 causes a syntax or validation error because it's invalid.

3. Final Answer:

   max should be max_length to specify maximum string length -> Option B

4. Quick Check:

   Use max_length, not max, in constr [OK]

Hint: Use max_length, not max, for string max length [OK]

Common Mistakes:

• Using max instead of max_length
• Confusing min_length with min
• Thinking constr is for int fields

5. You want to create a FastAPI model field password that must be between 8 and 16 characters and include at least one digit. Which is the correct way to define it?

hard

A. password: constr(min_length=8, max_length=16, regex=r'^(?=.*\\d).+$')

B. password: constr(min_length=8, max_length=16, regex=r'^[a-zA-Z]+$')

C. password: constr(min=8, max=16, regex=r'^(?=.*\\d).+$')

D. password: str(min_length=8, max_length=16, regex=r'^(?=.*\\d).+$')

Solution

1. Step 1: Check length parameters

   Use min_length=8 and max_length=16 in constr for length limits.

2. Step 2: Verify regex for digit inclusion

   The regex r'^(?=.*\\d).+$' ensures at least one digit is present.

3. Step 3: Validate option correctness

   password: constr(min_length=8, max_length=16, regex=r'^(?=.*\\d).+$') correctly combines length and regex. password: constr(min_length=8, max_length=16, regex=r'^[a-zA-Z]+$')'s regex disallows digits. password: constr(min=8, max=16, regex=r'^(?=.*\\d).+$') uses invalid min and max. password: str(min_length=8, max_length=16, regex=r'^(?=.*\\d).+$') wrongly applies regex to str type.

4. Final Answer:

   password: constr(min_length=8, max_length=16, regex=r'^(?=.*\\d).+$') -> Option A

5. Quick Check:

   Use constr with min_length, max_length, and digit regex [OK]

Hint: Use constr with min_length, max_length, and digit regex [OK]

Common Mistakes:

• Using min and max instead of min_length and max_length
• Using regex that excludes digits
• Trying to add regex to plain str type