Intermediate
Testing with real user data is a privacy nightmare. Testing with obviously fake data like “test@test.com” and “John Doe” makes your UI look broken in screenshots and demos. You need realistic-looking data: proper names, valid-format emails, real city names, plausible phone numbers, and dates that fall in sensible ranges — without ever touching a real person’s information.
The Faker library generates realistic synthetic data for exactly this purpose. It produces names, addresses, emails, phone numbers, company names, job titles, credit card numbers, UUIDs, dates, lorem ipsum text, and dozens of other data types — all in 70+ locales so you can generate German addresses, Japanese names, or Brazilian phone numbers with a simple parameter change.
This article covers installing Faker, generating basic data types, using locales, seeding for reproducibility, generating bulk data efficiently, creating custom providers, and building a complete test data factory. By the end you will be able to populate any test database, seed any demo environment, and write fixtures for any data shape your tests need.
Python Faker: Quick Example
# quick_faker.py
from faker import Faker
fake = Faker()
print(fake.name())
print(fake.email())
print(fake.address())
print(fake.phone_number())
print(fake.date_of_birth(minimum_age=18, maximum_age=65))
Jennifer Smith
jennifer.smith@example.org
742 Evergreen Terrace
Springfield, IL 62701
(555) 867-5309
1988-07-14
Create a Faker() instance once, then call any provider method on it. Each call generates a new random value. The interface is designed to be readable — fake.name() returns a full name, fake.email() returns an email — so test data generation code reads almost like plain English.
What Is Faker and When Should You Use It?
Faker is a Python port of the Ruby Faker gem, and provides “fake but realistic” data. This is different from random data (which looks obviously artificial) and different from real data (which carries privacy and compliance risks).
| Data Source | Realistic | Privacy Safe | Reproducible |
|---|---|---|---|
| Faker (seeded) | Yes | Yes | Yes |
| Faker (unseeded) | Yes | Yes | No |
| random strings | No | Yes | With seed |
| Real production data | Yes | No | Yes |
Use Faker in unit tests that need realistic-looking input data, when seeding a development database, when creating demo environments for client presentations, and when writing test fixtures that need varied but consistently-shaped data. Faker is not suitable for generating security tokens, cryptographic keys, or data that needs to satisfy complex business logic constraints — for that, use factory libraries like factory_boy or model_bakery that integrate with your ORM.
Installation
pip install Faker
Successfully installed Faker-24.3.0
Note the capital F in Faker for pip install. The import is also capitalized: from faker import Faker.
Core Providers: What Faker Can Generate
Faker organizes its data generators into “providers” — groups of related methods. Here are the most commonly used ones:
# core_providers.py
from faker import Faker
fake = Faker()
# Person data
print("=== Person ===")
print(fake.first_name(), fake.last_name())
print(fake.name())
print(fake.prefix(), fake.suffix())
print(fake.job())
print(fake.company())
print()
# Contact data
print("=== Contact ===")
print(fake.email())
print(fake.phone_number())
print(fake.url())
print(fake.user_name())
print()
# Location data
print("=== Location ===")
print(fake.address())
print(fake.city(), fake.state(), fake.postcode())
print(fake.country())
print(fake.latitude(), fake.longitude())
print()
# Date and time data
print("=== Dates ===")
print(fake.date_this_year())
print(fake.date_of_birth(minimum_age=21, maximum_age=60))
print(fake.date_time_between(start_date="-1y", end_date="now"))
print()
# Internet data
print("=== Internet ===")
print(fake.ipv4())
print(fake.mac_address())
print(fake.user_agent())
print()
# Finance data
print("=== Finance ===")
print(fake.credit_card_number())
print(fake.currency_code())
print(fake.pricetag())
=== Person ===
Jennifer Smith
Dr. Michael Johnson Jr.
Data Scientist
Tech Solutions Inc.
=== Contact ===
m.smith@example.com
(555) 123-4567
https://example.org/path
jennifer_s
=== Location ===
123 Main St
Springfield, IL 62701
United States
41.8781 -87.6298
=== Dates ===
2026-03-15
1985-04-22
2025-11-03 14:32:01
=== Internet ===
192.168.1.47
aa:bb:cc:dd:ee:ff
Mozilla/5.0 (Windows NT 10.0)
=== Finance ===
4532015112830366
USD
$47.99
Faker has over 100 provider methods in the standard library. The complete list is in the official documentation. Providers are grouped by theme: faker.providers.person, faker.providers.address, faker.providers.internet, and so on. When you call fake.email(), Faker uses the internet provider internally.
Using Locales for International Data
Pass a locale string to Faker() to generate data that matches a specific region’s conventions: Japanese names, French addresses, German phone number formats, etc.
# locales.py
from faker import Faker
# Single locale
fake_de = Faker("de_DE") # German
fake_ja = Faker("ja_JP") # Japanese
fake_br = Faker("pt_BR") # Brazilian Portuguese
print("=== German ===")
print(fake_de.name())
print(fake_de.address())
print(fake_de.phone_number())
print()
print("=== Japanese ===")
print(fake_ja.name())
print(fake_ja.address())
print()
print("=== Brazilian ===")
print(fake_br.name())
print(fake_br.cpf()) # CPF is a Brazilian ID number
# Multiple locales -- randomly picks from all of them
fake_multi = Faker(["en_US", "de_DE", "fr_FR", "ja_JP"])
print("\n=== Multi-locale (random each call) ===")
for _ in range(5):
print(fake_multi.name())
=== German ===
Klaus Muller
Hauptstrasse 15, 80331 Munchen
+49 89 12345678
=== Japanese ===
Yamamoto Taro
Tokyo-to, Shinjuku-ku
=== Brazilian ===
Carlos Silva
123.456.789-09
=== Multi-locale (random each call) ===
Alice Dupont
Taro Yamamoto
Heinrich Braun
Jennifer Smith
Marie Martin
The multi-locale mode selects randomly from the provided locales on each call. This is useful when testing an application that serves international users — your test data will naturally include a mix of name formats, address styles, and character sets, revealing encoding bugs and layout issues that single-locale test data would miss.
Seeding for Reproducible Test Data
By default, Faker generates different data on every run. For tests where you need the same data every time (stable test fixtures, snapshot tests, regression tests), use a seed:
# seeded_faker.py
from faker import Faker
# Seed makes output deterministic
Faker.seed(42)
fake = Faker()
print("Run 1:")
for _ in range(3):
print(f" {fake.name()} | {fake.email()}")
# Reset and re-seed -- same output
Faker.seed(42)
fake2 = Faker()
print("\nRun 2 (same seed):")
for _ in range(3):
print(f" {fake2.name()} | {fake2.email()}")
Run 1:
Jennifer Smith | j.smith@example.org
Michael Johnson | m.johnson@example.com
Sarah Davis | sarah.d@example.net
Run 2 (same seed):
Jennifer Smith | j.smith@example.org
Michael Johnson | m.johnson@example.com
Sarah Davis | sarah.d@example.net
Faker.seed() is a class-level call that sets the seed for all Faker instances. Use a fixed seed in your test setup to guarantee that test data is identical across runs, environments, and CI servers. Use no seed (or time-based seed) when you want different data every run to catch more edge cases. The tradeoff: seeded tests are stable and debuggable; unseeded tests provide broader coverage but can have intermittent failures.
Generating Bulk Data for Database Seeding
Generating large datasets for database seeding or performance testing requires generating thousands of records efficiently:
# bulk_seeding.py
from faker import Faker
import json
import time
fake = Faker()
Faker.seed(0)
def generate_users(count):
"""Generate a list of fake user records."""
users = []
for _ in range(count):
users.append({
"id": fake.uuid4(),
"username": fake.user_name(),
"email": fake.email(),
"full_name": fake.name(),
"job": fake.job(),
"city": fake.city(),
"country": fake.country_code(),
"joined_at": fake.date_time_between(
start_date="-2y", end_date="now"
).isoformat(),
"is_active": fake.boolean(chance_of_getting_true=80),
"score": round(fake.pyfloat(min_value=0, max_value=100, right_digits=2), 2),
})
return users
start = time.monotonic()
users = generate_users(10_000)
elapsed = time.monotonic() - start
print(f"Generated {len(users):,} users in {elapsed:.3f}s")
print(f"Sample record:")
print(json.dumps(users[0], indent=2))
Generated 10,000 users in 1.842s
Sample record:
{
"id": "a3f2c1d4-...",
"username": "jennifer_s42",
"email": "j.smith@example.com",
"full_name": "Jennifer Smith",
"job": "Data Scientist",
"city": "Austin",
"country": "US",
"joined_at": "2025-03-15T14:32:01",
"is_active": true,
"score": 73.45
}
Faker generates 10,000 records in about 2 seconds — fast enough for most seeding use cases. For performance-critical bulk generation (millions of records), consider using Faker in a multiprocessing pool or pre-generating data to a file. Note that fake.boolean(chance_of_getting_true=80) gives you weighted random booleans — 80% True, 20% False — which produces more realistic distributions than 50/50.
Real-Life Example: Pytest Fixture Factory
Here is how to wire Faker into a pytest fixture factory — a reusable pattern that generates test objects for different scenarios:
# test_user_service.py
import pytest
from faker import Faker
from dataclasses import dataclass
from typing import Optional
fake = Faker()
Faker.seed(999) # Stable test data across runs
@dataclass
class User:
id: int
name: str
email: str
age: int
is_active: bool = True
class UserFactory:
"""Factory for creating fake User objects in tests."""
_id_counter = 1
@classmethod
def create(cls, **overrides) -> User:
"""Create a User with fake data. Pass kwargs to override specific fields."""
defaults = {
"id": cls._id_counter,
"name": fake.name(),
"email": fake.email(),
"age": fake.random_int(min=18, max=70),
"is_active": True,
}
cls._id_counter += 1
return User(**{**defaults, **overrides})
@classmethod
def create_batch(cls, count: int, **overrides):
return [cls.create(**overrides) for _ in range(count)]
# Simple service to test
def get_active_users(users):
return [u for u in users if u.is_active]
def get_adult_users(users):
return [u for u in users if u.age >= 18]
# Tests
def test_get_active_users():
active = UserFactory.create_batch(3, is_active=True)
inactive = UserFactory.create_batch(2, is_active=False)
all_users = active + inactive
result = get_active_users(all_users)
assert len(result) == 3
assert all(u.is_active for u in result)
def test_get_adult_users():
adults = UserFactory.create_batch(4, age=25)
minors = UserFactory.create_batch(2, age=16)
all_users = adults + minors
result = get_adult_users(all_users)
assert len(result) == 4
def test_single_user_override():
# Override just the email -- all other fields are fake
user = UserFactory.create(email="specific@test.com")
assert user.email == "specific@test.com"
assert len(user.name) > 0 # name is still fake
if __name__ == "__main__":
# Quick sanity check without pytest
test_get_active_users()
test_get_adult_users()
test_single_user_override()
print("All tests passed!")
All tests passed!
The factory pattern with **overrides is the standard approach: each test specifies only the fields it cares about and lets Faker fill in the rest. This keeps tests focused and readable. When you need to test a specific email format, you pass email="..."; everything else stays realistic. The _id_counter ensures each factory-created object has a unique ID across all tests in the session.
Frequently Asked Questions
How do I generate unique values (no duplicates)?
Use fake.unique.email() — the unique proxy ensures no value is repeated within the current Faker instance’s session. It tracks all previously returned values and retries until it finds a new one. Call fake.unique.clear() to reset the uniqueness tracking if you need to generate fresh values. Note that uniqueness is per-instance and per-provider: fake.unique.email() tracks emails separately from fake.unique.name().
Can I add my own custom data generators to Faker?
Yes. Subclass BaseProvider and add it: fake.add_provider(MyProvider). Your provider methods become available as fake.my_method(). This is useful for domain-specific data: product SKUs, internal ID formats, company-specific status codes. The Faker documentation has a full example of a custom provider.
How do I generate data in a specific format like a US SSN?
Use fake.ssn() from the en_US locale. Faker has locale-specific providers for national ID formats, postal codes, phone number formats, and currency. If a provider does not exist for your format, use fake.numerify("###-##-####") to generate a numeric pattern where # is replaced by a random digit, or fake.bothify("??##") which replaces ? with a letter and # with a digit.
Is Faker fast enough for generating millions of records?
Faker generates roughly 5,000-10,000 records per second for typical use cases. For millions of records, use multiprocessing.Pool to parallelize across CPU cores, or generate data in batches and write to disk incrementally. For very large datasets, consider mimesis, an alternative to Faker that claims 10x faster generation by avoiding Python’s slow string operations in some providers.
Why does my seeded Faker still produce different results between runs?
The most common cause: calling Faker.seed(n) after creating the instance, or creating multiple instances before seeding. The correct order is: call Faker.seed(n) first, then create your Faker() instance. If your tests run in a different order between sessions, the number of Faker calls before your test code can also vary, shifting the output. Use a fixture that resets the seed before each test: @pytest.fixture(autouse=True) def seed_faker(): Faker.seed(42).
Conclusion
Faker is the standard tool for generating realistic synthetic test data in Python. You have seen how to use core providers for names, emails, addresses, and dates; how locales let you generate international data; how seeding makes test data deterministic; how to generate bulk datasets for database seeding; and how the factory pattern with **overrides integrates cleanly into pytest. The official Faker documentation at faker.readthedocs.io has the complete list of providers across all 70+ supported locales.