FakeJSON

Overview

FakeJSON is a service designed to assist developers and quality assurance teams by providing on-demand, customizable JSON data. It addresses the common challenge of acquiring sufficient and realistic data for various development and testing scenarios. Developers can define custom JSON schemas, specifying data types, formats, and relationships, and FakeJSON's API will generate data that adheres to these specifications. This capability is particularly useful for tasks such as mocking API endpoints during front-end development, populating local or staging databases with diverse data sets, and creating predictable yet varied data for automated UI tests.

The platform's utility extends across the software development lifecycle. During initial development phases, it allows front-end teams to proceed without waiting for back-end APIs to be fully implemented, by providing mock data that simulates real API responses. For back-end developers, it offers a way to seed databases with large volumes of test data, facilitating performance testing and data model validation. QA teams can leverage FakeJSON to generate edge cases, error conditions, and specific data permutations, enhancing test coverage and robustness. The service supports a range of data types, including names, addresses, dates, numbers, and custom regex patterns, enabling the creation of tailored data sets for specific application requirements.

FakeJSON's API is designed for ease of integration, offering clear documentation and code examples in common languages like cURL and JavaScript. This focus on developer experience minimizes the learning curve and allows for rapid adoption into existing workflows. The service's flexibility in schema definition means it can accommodate simple data structures as well as complex, nested JSON objects, making it adaptable for various project scales and data complexities. By automating the data generation process, FakeJSON aims to reduce manual effort, accelerate development cycles, and improve the quality of testing data across different stages of software development.

Key features

• Custom Schema Definition: Users can define JSON schemas to specify the structure and types of data to be generated. This includes support for arrays, nested objects, and various primitive data types (FakeJSON documentation on schema definition).
• Wide Range of Data Types: Supports common data types such as names, email addresses, phone numbers, dates, times, geographic coordinates, and lorem ipsum text.
• Dynamic Data Generation: Generates unique data for each request or based on specified data constraints, ensuring variety in test data.
• API Endpoint: Provides a RESTful API for programmatic data generation, allowing integration into automated scripts and applications (FakeJSON API endpoints).
• Customizable Data Formats: Allows for specifying data formats, such as date formats or number ranges, to match application requirements.
• Repeatable Data: Ability to generate consistent data for specific scenarios, which is useful for debugging and reproducible tests.
• Developer-Friendly Documentation: Offers clear documentation with code examples in cURL and JavaScript to facilitate quick integration.

Pricing

FakeJSON offers a free tier for initial use and provides scaled paid plans based on request volume. The pricing structure is designed to accommodate different usage levels, from individual developers to larger teams with higher data generation needs.

Common integrations

FakeJSON is primarily integrated through its REST API, making it compatible with any system capable of making HTTP requests. While it doesn't offer specific pre-built SDKs, its API-first design allows for broad integration.

• Test Automation Frameworks: Can be integrated with frameworks like Jest, Mocha, or Cypress to generate test data on the fly for UI and API tests.
• CI/CD Pipelines: Used within continuous integration and continuous delivery pipelines to automatically provision test data for automated deployments and testing stages.
• Front-end Development: Developers can integrate FakeJSON into their front-end applications to mock API responses during local development, using tools like webpack-dev-server or similar local proxies.
• Back-end Development: Used by back-end developers to seed databases or simulate external service responses during development and testing.
• Postman/Insomnia: Can be called directly from API development tools like Postman or Insomnia to generate sample request bodies or mock responses.
• JavaScript Applications: Directly usable within JavaScript environments (browser or Node.js) to fetch data for dynamic content or testing.

Alternatives

Several tools and libraries offer similar functionality for generating mock data or testing APIs. Each has a different focus or mode of operation:

• Mockaroo: A web-based data generator that allows users to define schemas and download data in various formats, including JSON, CSV, and SQL.
• JSONPlaceholder: A free online REST API that serves fake data for testing and prototyping, offering pre-defined endpoints for common resources like posts, comments, and users.
• Faker.js: A JavaScript library for generating massive amounts of realistic fake data in Node.js and browsers, useful for client-side or server-side data generation without an external API call. Faker.js provides a local alternative to API-based data generation services, as noted in its Faker.js usage guide.
• Tray.io: While primarily an integration platform, Tray.io can be used to construct mock data flows for testing integrations, although it's a more complex solution for simple data generation.
• Kong Gateway: Can be configured with plugins to mock API responses, acting as a proxy for test data, but requires more infrastructure setup.

Getting started

To begin generating JSON data with FakeJSON, you typically define your desired schema and make an HTTP POST request to the FakeJSON API endpoint. The following example demonstrates how to generate a list of 5 users, each with a name and email, using cURL and JavaScript.

cURL Example

curl -X POST \
  https://api.fakejson.com/api/fake \
  -H 'Content-Type: application/json' \
  -d '{
    "token": "YOUR_API_TOKEN",
    "data": {
      "id": "@id",
      "name": "@fullname",
      "email": "@email",
      "_repeat": 5
    }
  }'

JavaScript Example (Node.js using fetch)

async function generateFakeUsers() {
  const response = await fetch('https://api.fakejson.com/api/fake', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      token: 'YOUR_API_TOKEN', // Replace with your actual API token
      data: {
        id: '@id',
        name: '@fullname',
        email: '@email',
        _repeat: 5
      }
    })
  });

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  const data = await response.json();
  console.log(data);
}

generateFakeUsers().catch(console.error);

In both examples, YOUR_API_TOKEN should be replaced with an actual API token obtained from your FakeJSON account. The data object defines the structure of the JSON to be generated, using special @ prefixed keywords like @id, @fullname, and @email to specify the type of fake data to insert. The _repeat property indicates how many times the data object should be duplicated in an array.