Skip to main content

Guide

@faker-js/faker vs Chance.js vs Casual 2026

Compare @faker-js/faker, Chance.js, and Casual for generating fake test data in Node.js. Locale support, TypeScript types, seeding for reproducibility, and.

·PkgPulse Team·
0

TL;DR

@faker-js/faker is the default choice in 2026 — it's the community-maintained fork of the original faker.js with full TypeScript support, extensive locales, and seeded random generation for reproducible test data. Chance.js is the battle-tested alternative with a clean API focused on probability distributions. Casual is a simpler option for quick fake data without the overhead. For most projects, faker is the right choice.

Key Takeaways

  • @faker-js/faker: ~5.8M weekly downloads — TypeScript-native, 60+ locales, seeded random
  • chance: ~1.8M weekly downloads — probability-focused, clean API, good for custom distributions
  • casual: ~250K weekly downloads — lightweight, minimal API, no TypeScript types
  • @faker-js/faker replaced the original unmaintained faker package in 2022
  • Seed your faker for reproducible test data — same seed = same data every run
  • Use faker for database seeding, Storybook stories, API mocks, and unit test fixtures
PackageWeekly DownloadsTypeScriptLocalesSeedable
@faker-js/faker~5.8M✅ Native60+✅
chance~1.8M✅ @types10+✅
casual~250K❌Limited✅

@faker-js/faker

@faker-js/faker is the community-maintained fork with extensive data modules and full TypeScript support.

Basic Data Generation

import { faker } from "@faker-js/faker"

// Person data:
const name = faker.person.fullName()        // "John Smith"
const firstName = faker.person.firstName()  // "Emily"
const lastName = faker.person.lastName()    // "Johnson"
const jobTitle = faker.person.jobTitle()    // "Senior Software Engineer"
const bio = faker.person.bio()              // "Helping people with their needs."

// Internet:
const email = faker.internet.email()        // "emily.johnson@example.com"
const username = faker.internet.username()  // "emily_johnson_42"
const url = faker.internet.url()            // "https://gentle-llama.net"
const avatar = faker.image.avatar()         // "https://avatars.githubusercontent.com/..."

// Numbers and ids:
const id = faker.string.uuid()              // "abc123-..."
const nanoid = faker.string.nanoid()        // "V1StGXR8_Z5jdHi6B-myT"
const num = faker.number.int({ min: 1, max: 100 })
const float = faker.number.float({ min: 0, max: 1, fractionDigits: 2 })

// Text:
const word = faker.word.noun()              // "mountain"
const sentence = faker.lorem.sentence()     // "Lorem ipsum dolor sit amet."
const paragraph = faker.lorem.paragraph(3) // Multi-sentence paragraph

// Dates:
const pastDate = faker.date.past()          // Date in the past
const recentDate = faker.date.recent({ days: 7 })  // Last 7 days
const futureDate = faker.date.future({ years: 1 })  // Next year

// Commerce:
const price = faker.commerce.price({ min: 1, max: 100 })  // "42.99"
const productName = faker.commerce.productName()            // "Ergonomic Chair"
const department = faker.commerce.department()              // "Outdoors"

// Location:
const city = faker.location.city()          // "New York"
const country = faker.location.country()    // "United States"
const zipCode = faker.location.zipCode()    // "10001"
const lat = faker.location.latitude()
const lng = faker.location.longitude()

Seeded Generation (Reproducible Test Data)

import { faker } from "@faker-js/faker"

// Set seed for reproducible data:
faker.seed(12345)

const user1 = {
  id: faker.string.uuid(),
  name: faker.person.fullName(),
  email: faker.internet.email(),
}
// Always generates the same output with seed 12345

// Reset seed for random:
faker.seed()  // No arg = random seed

// Or create a scoped instance with seed:
const seededFaker = new Faker({ locale: [en], seed: 12345 })

Building Test Fixtures

import { faker } from "@faker-js/faker"

// Factory function pattern:
function createUser(overrides: Partial<User> = {}): User {
  return {
    id: faker.string.uuid(),
    name: faker.person.fullName(),
    email: faker.internet.email(),
    avatar: faker.image.avatar(),
    createdAt: faker.date.past({ years: 2 }),
    role: faker.helpers.arrayElement(["admin", "editor", "viewer"] as const),
    weeklyDownloads: faker.number.int({ min: 0, max: 10000000 }),
    ...overrides,  // Allow tests to override specific fields
  }
}

function createPackage(overrides: Partial<Package> = {}): Package {
  const name = faker.internet.domainWord()
  return {
    id: faker.string.uuid(),
    name,
    description: faker.lorem.sentences(2),
    version: faker.system.semver(),
    weeklyDownloads: faker.number.int({ min: 100, max: 25000000 }),
    license: faker.helpers.arrayElement(["MIT", "Apache-2.0", "ISC", "GPL-3.0"]),
    author: faker.person.fullName(),
    publishedAt: faker.date.past({ years: 5 }),
    ...overrides,
  }
}

// Create arrays with unique values:
function createPackages(count: number): Package[] {
  return faker.helpers.uniqueArray(
    () => createPackage(),
    count
  )
}

// Test usage:
const testPackage = createPackage({ name: "react", weeklyDownloads: 25000000 })
const testUser = createUser({ role: "admin" })
const packageList = createPackages(10)

Locales

import { faker } from "@faker-js/faker"
import { de, fr, ja, zh_CN } from "@faker-js/faker"

// Locale-specific data:
const germanFaker = new Faker({ locale: [de] })
console.log(germanFaker.location.city())  // "München"
console.log(germanFaker.person.fullName())  // "Hans-Werner Schmidt"

const japaneseFaker = new Faker({ locale: [ja] })
console.log(japaneseFaker.person.fullName())  // "田中 太郎"

// Fallback locales (use base locale for missing data):
import { base } from "@faker-js/faker"
const frenchWithFallback = new Faker({ locale: [fr, base] })

Database Seeding

import { faker } from "@faker-js/faker"
import { PrismaClient } from "@prisma/client"

const prisma = new PrismaClient()

async function seedDatabase() {
  faker.seed(42)  // Deterministic seed for consistent dev data

  // Create users:
  const users = await Promise.all(
    Array.from({ length: 20 }, () =>
      prisma.user.create({
        data: {
          id: faker.string.uuid(),
          email: faker.internet.email(),
          name: faker.person.fullName(),
          createdAt: faker.date.past({ years: 2 }),
        },
      })
    )
  )

  // Create packages:
  const packageNames = ["react", "vue", "angular", "svelte", "solid-js"]
  await Promise.all(
    packageNames.map((name) =>
      prisma.package.create({
        data: {
          name,
          description: faker.lorem.sentences(2),
          weeklyDownloads: faker.number.int({ min: 100000, max: 25000000 }),
          version: faker.system.semver(),
        },
      })
    )
  )
}

Chance.js

Chance.js is focused on probability distributions — useful when you need weighted random data or specific statistical properties.

import Chance from "chance"

const chance = new Chance()
const seededChance = new Chance(42)  // Reproducible with seed

// Person:
const name = chance.name()            // "John Smith"
const email = chance.email()          // "abc@example.com"
const phone = chance.phone()          // "(555) 555-1234"
const age = chance.age({ type: "adult" })  // 25-65

// Addresses:
const city = chance.city()
const country = chance.country({ full: true })
const zip = chance.zip()

// Booleans with probability:
const isActive = chance.bool({ likelihood: 80 })  // 80% chance true
const hasPro = chance.bool({ likelihood: 20 })     // 20% chance true

// Weighted picks:
const tier = chance.weighted(
  ["free", "pro", "enterprise"],
  [70, 25, 5]  // 70% free, 25% pro, 5% enterprise
)

// Strings:
const randomString = chance.string({ length: 8, pool: "abcdefghijklmnopqrstuvwxyz" })
const hash = chance.hash({ length: 32 })

// Custom distributions:
const downloads = chance.normal({ mean: 10000, dev: 5000 })  // Normal distribution
const exponential = chance.exp({ rate: 0.001 })  // Exponential distribution

Chance.js custom definitions:

// Extend with custom generators:
Chance.prototype.npmPackage = function() {
  const names = ["react", "vue", "angular", "lodash", "express", "axios"]
  return this.pickone(names)
}

const chance = new Chance()
const pkg = (chance as any).npmPackage()  // Returns a random package name

casual

casual is the simplest option — no configuration, immediate use:

import casual from "casual"

// No instantiation needed:
console.log(casual.name)         // "John Smith"
console.log(casual.email)        // "john@example.com"
console.log(casual.url)          // "http://example.com"
console.log(casual.title)        // "Chief Executive Officer"
console.log(casual.description)  // Short text

// Re-access generates new data:
console.log(casual.name)  // "Jane Doe"  (different each time)

// Seed:
casual.seed(42)
console.log(casual.name)  // Same each time with this seed

casual has no TypeScript types — use @types/casual or cast with as any.

Feature Comparison

Feature@faker-js/fakerChance.jscasual
TypeScript✅ Native✅ @types❌
Weekly downloads~5.8M~1.8M~250K
Locales60+10+Limited
Seeded random✅✅✅
Probability/weights⚠️ Limited✅ Excellent❌
Normal distribution❌✅❌
Custom generators✅✅✅
Faker modules50+ categoriesGeneralGeneral
Bundle size~4MB (full)~170KB~30KB
Tree-shakable✅❌❌
Active development✅✅⚠️ Slow

When to Use Each

Choose @faker-js/faker if:

  • Generating test fixtures, Prisma seeds, or Storybook mock data
  • You need locale-specific data (German addresses, Japanese names, etc.)
  • TypeScript is required
  • You want a comprehensive library covering persons, commerce, internet, systems

Choose Chance.js if:

  • You need weighted/probability distributions (e.g., 80% of users are free tier)
  • Generating statistically realistic data distributions
  • Simulating real-world skewed data (most users have few downloads; few have millions)

Choose casual if:

  • Quick scripts where simplicity beats features
  • You're prototyping and don't need TypeScript
  • Bundle size matters and you only need basic data types

Migration Guide

From the deprecated faker package to @faker-js/faker

The original faker npm package was famously deleted and then abandoned by its creator in January 2022. The community forked it as @faker-js/faker. The API is nearly identical — the primary change is the package name and the import path:

# Remove the old package
npm uninstall faker

# Install the community fork
npm install --save-dev @faker-js/faker

// Before: faker (deprecated)
import faker from "faker"
const name = faker.name.findName()       // Old API
const email = faker.internet.email()
const city = faker.address.city()        // address module
const phone = faker.phone.phoneNumber()  // phone module

// After: @faker-js/faker (current)
import { faker } from "@faker-js/faker"
const name = faker.person.fullName()     // person module (renamed)
const email = faker.internet.email()     // same
const city = faker.location.city()       // location module (renamed from address)
const phone = faker.phone.number()       // phone module (simplified)

Key module renames in @faker-js/faker v8+:

  • faker.name → faker.person
  • faker.address → faker.location
  • faker.phone.phoneNumber() → faker.phone.number()
  • faker.datatype.number() → faker.number.int()
  • faker.datatype.float() → faker.number.float()
  • faker.datatype.uuid() → faker.string.uuid()

Adding reproducible seeding to existing faker usage

If your test suite uses faker without seeding, each test run generates different data, making test failures intermittent and hard to reproduce:

// Before: unseeded (different data every run — hard to debug failures)
const user = {
  name: faker.person.fullName(),
  email: faker.internet.email(),
}

// After: seeded in beforeEach (same data every run)
beforeEach(() => {
  faker.seed(12345)
})

afterEach(() => {
  faker.seed() // Reset to random after each test
})

const user = {
  name: faker.person.fullName(), // Always "Alice Smith" with seed 12345
  email: faker.internet.email(), // Always "alice.smith@example.com"
}

For Vitest, use faker.seed(expect.getState().currentTestName.split("").reduce((a, c) => a + c.charCodeAt(0), 0)) to get per-test deterministic seeds based on test names.

Reproducibility and CI Integration

One of the most underappreciated features of test data generators is deterministic seeding. Without seeding, every test run generates different random data — a test that fails due to an edge case in a randomly generated value is nearly impossible to reproduce in isolation. @faker-js/faker solves this with faker.seed(number), which initializes the internal PRNG (pseudo-random number generator) state. The same seed always produces the same sequence of generated values, regardless of Node.js version or platform. In Vitest, the recommended pattern is to derive the seed from the test name — faker.seed(expect.getState().currentTestName.split('').reduce((a, c) => a + c.charCodeAt(0), 0)) — giving each test a unique but deterministic seed that can be reproduced by running that specific test again.

In CI pipelines, seeded faker calls enable snapshot testing of generated data. A Prisma seed script with faker.seed(42) at the top will generate the exact same user records, package records, and relationships every time the seed is run — making the seeded database state predictable for integration tests. Teams can commit the expected seed output as a snapshot and fail CI if the generated data changes unexpectedly (which would indicate a schema migration broke the seed script). This is particularly useful in end-to-end test suites where Playwright or Cypress expects specific users or content to exist in the test database.

Locale Data Quality and Edge Cases

The 60+ locale support in @faker-js/faker varies significantly in data quality across locales. Western European locales (de, fr, es, pt_BR) are well-maintained with accurate city names, phone formats, postal codes, and culturally appropriate person names. East Asian locales (ja, zh_CN, ko) include correct script-based names but have fewer data categories than the English base locale. The Faker constructor's locale fallback system — passing [ja, base] — transparently falls back to the base English locale for any category the target locale doesn't implement, preventing missing-data errors while still generating culturally appropriate values for the categories the target locale does support.

Chance.js supports a smaller set of locales but its locale handling focuses on phone number formats and address structures, which is where locale-specific data matters most in testing telephone-handling and address-validation logic. For teams testing systems that handle international phone numbers and need realistic E.164 format validation, Chance.js's phone generator with locale options produces format-correct numbers, whereas faker's phone module generates numbers in local notation that may not parse correctly with libraries like libphonenumber-js without additional normalization. This distinction matters in automated test suites for contact management systems and international e-commerce platforms.

Community Adoption in 2026

@faker-js/faker reaches approximately 5.8 million weekly downloads, making it one of the most widely used testing utility packages in the JavaScript ecosystem. The dramatic backstory — creator deleted the package, community forked it within days, the new team has since released multiple major versions with improved TypeScript support and breaking-change cleanup — has made @faker-js/faker something of a community success story. The v9 API reorganization (renaming modules to be more consistent and intuitive) was a breaking change that demonstrated the community's willingness to improve the API rather than maintain backward compatibility indefinitely. @faker-js/faker is the default in virtually every project scaffolded with testing in mind: Prisma seed scripts, Storybook mocking, Playwright test fixtures, and Jest/Vitest unit test factories all reach for faker. The 60+ locale support makes it the only option for applications that need realistic locale-specific test data.

Chance.js maintains approximately 1.8 million weekly downloads, serving a niche that faker doesn't cover well: statistical distributions and weighted random generation. If you need to simulate a realistic user population where 70% are free users, 25% are pro users, and 5% are enterprise users — and you want that distribution to hold across thousands of generated test records — Chance.js's weighted() function and normal/exponential distribution generators are essential. faker has arrayElement for simple random picks but no concept of probability weights or statistical distributions. For simulation testing, load testing with realistic traffic patterns, and analytics validation with realistic data distributions, Chance.js's probability focus is uniquely valuable.

casual at approximately 250,000 weekly downloads serves developers who need quick fake data without installation friction or TypeScript configuration. Its property-based API — casual.name, casual.email, casual.url as properties rather than function calls — is the most minimal interface in this comparison. The lack of TypeScript types is a significant limitation in TypeScript projects, requiring either as any casts or installing community-maintained @types/casual. Development activity has been slow, and for any project where TypeScript and reproducibility matter, @faker-js/faker is the better choice. casual's download count is partly sustained by older projects that have not been updated, rather than new adopters choosing it over faker.

Methodology

Download data from npm registry (weekly average, February 2026). Feature comparison based on @faker-js/faker v9.x, Chance.js v1.x, and casual v0.6.x.

Compare testing and developer tool packages on PkgPulse →

See also: supertest vs fastify.inject vs hono/testing and sinon vs jest.mock vs vi.fn 2026, acorn vs @babel/parser vs espree.

The 2026 JavaScript Stack Cheatsheet

One PDF: the best package for every category (ORMs, bundlers, auth, testing, state management). Used by 500+ devs. Free, updated monthly.