Bored

Overview

Bored is a cloud-based platform that provides API mocking capabilities, intended to streamline development and testing workflows. It allows developers to create simulated API endpoints that return predefined responses, eliminating the need for a fully functional backend during the initial stages of application development or for comprehensive testing scenarios. This approach enables frontend and mobile development teams to progress independently, without waiting for backend services to be fully implemented or stabilized.

The platform is designed to support several use cases, including rapid API prototyping and developer sandboxing. By configuring mock endpoints through a user interface, developers can quickly set up various response types, status codes, and latency simulations. This deterministic behavior is beneficial for creating consistent and repeatable test environments, crucial for automated testing pipelines and reducing flaky test results. Bored's focus is on providing a lightweight solution that emphasizes ease of use, reducing the setup overhead often associated with local mocking tools or custom backend simulations.

Bored's core offerings include API mocking, request/response logging, and scenario-based testing. Request logging provides visibility into the interactions with mock APIs, aiding in debugging and validation. Scenario-based testing extends this by allowing the definition of multiple response variations for a single endpoint, triggered by specific request parameters or sequences. This facilitates testing complex application flows that depend on different API states or data conditions. The platform aims to serve individual developers, small teams, and larger organizations looking to optimize their API-dependent development cycles.

While similar functionality can be achieved with self-hosted solutions like WireMock's standalone server or desktop applications such as Mockoon for local development, Bored differentiates itself by offering a cloud-native, managed service. This eliminates the need for local setup and maintenance, providing a consistent environment accessible across teams. Such cloud-based services can also integrate more readily into continuous integration/continuous deployment (CI/CD) pipelines, offering on-demand mock services for automated tests. The architecture supports a straightforward UI for defining mocks and basic management tools, positioning it as a tool for quick setup and iteration in environments where backend availability or stability is a constraint.

Key features

• API Mocking: Create customizable mock endpoints that simulate real API behavior, including HTTP methods, status codes, and response bodies, often defined in JSON.
• Request/Response Logging: Capture and review incoming requests to mock APIs and the corresponding mock responses, aiding in debugging and validation.
• Scenario-Based Testing: Define multiple response scenarios for a single endpoint, allowing tests to simulate different API states or sequential interactions based on request conditions.
• Cloud-Based Platform: Managed service accessible via a web interface, removing the need for local installation and maintenance of mocking infrastructure.
• Latency Simulation: Configure artificial delays for mock responses to simulate network latencies or slow API performance, useful for testing client-side loading states.
• CORS Support: Automatic handling of Cross-Origin Resource Sharing (CORS) headers to ensure compatibility with browser-based frontend applications.

Pricing

As of 2026-05-28, Bored offers a free developer plan and two paid tiers. Details are available on the Bored pricing page.

Common integrations

Bored's cloud-based API mocks are designed to be consumed by any HTTP client, making them compatible with various development tools and frameworks. While there are no direct SDKs, common integration patterns include:

• Frontend Frameworks: Used by applications built with React, Angular, Vue.js, or Svelte to develop user interfaces against stable API contracts.
• Mobile Development: iOS and Android applications can connect to Bored's mock APIs during development and testing phases.
• Automated Testing Suites: Integrate with frameworks like Jest, Cypress, Playwright, or Selenium to provide predictable API responses for end-to-end or integration tests.
• CI/CD Pipelines: Deploy mock APIs as part of build and test stages in Jenkins, GitHub Actions, GitLab CI, or CircleCI to ensure consistent testing environments.
• API Clients: Tools like Postman or Insomnia can be used to interact with and test the configured mock endpoints.

Alternatives

For API mocking and testing, several alternatives exist, varying in deployment model and feature set:

• Postman: A comprehensive API development environment that includes built-in mocking capabilities, often used for local development and collaboration.
• Mockoon: An open-source desktop application that provides a local server for creating and serving mock APIs.
• WireMock: A flexible library for stubbing and mocking web services, available as a standalone server or a Java library.
• MSW (Mock Service Worker): An API mocking library that intercepts network requests at the service worker level, allowing frontend developers to mock API calls directly in the browser.
• Prism (Stoplight): An OpenAPI-powered HTTP mock server that generates mocks from an OpenAPI document, useful for design-first API development.

Getting started

To begin using Bored, you typically define your mock endpoints and responses through its web interface. Once configured, you can consume these mocks by sending HTTP requests to the provided mock URL. Here's an example of how a JavaScript frontend application might fetch data from a Bored mock endpoint:

// Assume 'your-mock-id' is the unique ID generated by Bored for your mock API
// And '/users' is an endpoint you've defined to return a list of users.
const MOCK_API_BASE_URL = 'https://mock.bored.dev/your-mock-id';

async function fetchUsers() {
  try {
    const response = await fetch(`${MOCK_API_BASE_URL}/users`);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const users = await response.json();
    console.log('Fetched users:', users);
    // Render users in your UI
  } catch (error) {
    console.error('Error fetching users:', error);
  }
}

fetchUsers();

/* Example Mock Response (configured in Bored UI for /users GET request):
[
  {
    "id": 1,
    "name": "Alice Smith",
    "email": "[email protected]"
  },
  {
    "id": 2,
    "name": "Bob Johnson",
    "email": "[email protected]"
  }
]
*/

This example demonstrates a basic GET request. For more complex scenarios, you would configure Bored to handle different HTTP methods (POST, PUT, DELETE), specific request headers, or body content, and define corresponding mock responses including dynamic data generation or error simulations. The Bored API reference provides further details on configuring various mock behaviors.