Generate Fake Data in C# Using Bogus

When building applications, especially APIs and data-driven systems, having realistic data is important. But manually creating test data is time-consuming and often doesn’t reflect real-world scenarios.

This is where Bogus helps. It allows generating fake but realistic data quickly, which is useful for development, testing, and demos.

Bogus is a powerful and widely used .NET library for generating realistic fake data in C#. It is commonly used by developers to simulate real-world data without relying on actual production data.

The library provides built-in generators (called data sets) for common data types such as:

• Names and usernames
• Emails and phone numbers
• Addresses and locations
• Dates, finance data, and more

What makes Bogus stand out is its fluent API, which allows defining rules in a clean and readable way. Instead of hardcoding values, you describe how data should look, and Bogus generates it dynamically.

This makes it ideal for:

• Testing APIs and business logic
• Seeding development databases
• Building demos without exposing real data

Using Bogus improves both development speed and data quality.

Key benefits:

• Realistic data generation – The data looks natural and follows real-world patterns, making testing more meaningful.
• Faster development workflow – No need to manually create large datasets.
• Highly customizable – You can define rules based on your domain logic.
• Safe for testing – Avoids using sensitive or production data.
• Repeatable results (with seeding) – Ensures consistent outputs when needed.

Overall, Bogus helps simulate real-world scenarios without complexity.

Install Bogus via NuGet:

dotnet add package Bogus

dotnet add package Bogus

The simplest way to use Bogus is by creating a Faker instance and generating values:

using Bogus;

var faker = new Faker();

var name = faker.Name.FullName();
var email = faker.Internet.Email();
var address = faker.Address.FullAddress();

Console.WriteLine($"{name} - {email} - {address}");

using Bogus;

var faker = new Faker();

var name = faker.Name.FullName();
var email = faker.Internet.Email();
var address = faker.Address.FullAddress();

Console.WriteLine($"{name} - {email} - {address}");

What’s happening here?

• Faker provides access to multiple data categories
• Each property (like Name, Internet, Address) generates realistic values
• Every run produces different data

This is useful for quick testing or generating sample values.

In real applications, you often need full objects instead of single values.

Bogus supports this using Faker<T>:

using Bogus;

public sealed class Customer
{
    public Guid Id { get; set; }
    public string Name { get; set; } = default!;
    public string Email { get; set; } = default!;
    public string City { get; set; } = default!;
}

var customerFaker = new Faker<Customer>()
    .RuleFor(c => c.Id, f => Guid.CreateVersion7())
    .RuleFor(c => c.Name, f => f.Name.FullName())
    .RuleFor(c => c.Email, f => f.Internet.Email())
    .RuleFor(c => c.City, f => f.Address.City());

var customers = customerFaker.Generate(5);

foreach (var customer in customers)
{
    Console.WriteLine($"ID: {customer.Id}");
    Console.WriteLine($"Name: {customer.Name}");
    Console.WriteLine($"Email: {customer.Email}");
    Console.WriteLine($"City: {customer.City}");
    Console.WriteLine();
}

using Bogus;

public sealed class Customer
{
    public Guid Id { get; set; }
    public string Name { get; set; } = default!;
    public string Email { get; set; } = default!;
    public string City { get; set; } = default!;
}

var customerFaker = new Faker<Customer>()
    .RuleFor(c => c.Id, f => Guid.CreateVersion7())
    .RuleFor(c => c.Name, f => f.Name.FullName())
    .RuleFor(c => c.Email, f => f.Internet.Email())
    .RuleFor(c => c.City, f => f.Address.City());

var customers = customerFaker.Generate(5);

foreach (var customer in customers)
{
    Console.WriteLine($"ID: {customer.Id}");
    Console.WriteLine($"Name: {customer.Name}");
    Console.WriteLine($"Email: {customer.Email}");
    Console.WriteLine($"City: {customer.City}");
    Console.WriteLine();
}

Why this is powerful:

• Generates fully populated objects
• Keeps data consistent and structured
• Works well for APIs and testing

Bogus allows defining custom rules using .RuleFor().

var customerFaker = new Faker<Customer>()
    .RuleFor(c => c.Id, f => Guid.CreateVersion7())
    .RuleFor(c => c.Name, f => f.Name.FullName())
    // Generates an email based on the generated Name
    // f = Bogus faker context (provides methods like Internet, Name, Address)
    // c = current Customer object being created (so we can access c.Name)
    .RuleFor(c => c.Email, (f, c) => f.Internet.Email(c.Name))
    .RuleFor(c => c.City, f => f.Address.City());

var customerFaker = new Faker<Customer>()
    .RuleFor(c => c.Id, f => Guid.CreateVersion7())
    .RuleFor(c => c.Name, f => f.Name.FullName())
    // Generates an email based on the generated Name
    // f = Bogus faker context (provides methods like Internet, Name, Address)
    // c = current Customer object being created (so we can access c.Name)
    .RuleFor(c => c.Email, (f, c) => f.Internet.Email(c.Name))
    .RuleFor(c => c.City, f => f.Address.City());

Why use custom rules?

• Create relationships between properties
• Match real business logic
• Generate domain-specific data

For example:

• Email based on name
• Age based on date of birth
• Status based on conditions

This makes the generated data more realistic and meaningful.

By default, Bogus generates random data every time the code runs. This is great for general testing, but in some scenarios, completely random data can cause issues.

For example:

• Unit tests may fail because data changes on each run
• Debugging becomes harder since results are not repeatable
• Snapshot or comparison tests may break

To solve this, Bogus supports seeding.

Randomizer.Seed = new Random(123);

var customers = customerFaker.Generate(3);

Randomizer.Seed = new Random(123);

var customers = customerFaker.Generate(3);

What does seeding do?

Seeding sets a fixed starting point for the random generator. This means:

• The same input always produces the same output
• Data generation becomes predictable and repeatable

Why this is important:

• Reliable tests – Test results stay consistent
• Easier debugging – Same data helps reproduce issues
• Stable demos – Avoid unexpected changes in output

Bogus supports multiple locales, allowing you to generate region-specific data.

var faker = new Faker(locale: "de"); // German

var faker = new Faker(locale: "de"); // German

Why this is useful:

• Test applications for different regions
• Validate formatting logic
• Build global-ready systems

Bogus is useful in:

• Unit and integration testing
• Database seeding during development
• Creating demo data for APIs
• UI prototyping with realistic content

This makes the generated data more realistic and meaningful.

Bogus is a simple and powerful library for generating realistic fake data in C#. It improves development speed, enhances testing quality, and helps create better demos without relying on real data.

• Bogus generates realistic fake data in C# applications
• Easy to use with a clean API
• Supports complex object generation
• Custom rules allow domain-specific data
• Seeding ensures consistent and repeatable results