# Bruno API Client Mock Server: How to Mock APIs with Bruno

If you're using Bruno as your API client, you've probably noticed it doesn't come with a built-in mock server. Unlike Postman, which includes a mock server feature bundled into its platform, Bruno is focused on being a fast, open-source, offline-first API client — and that's what makes it great.

But when you need to mock an API for frontend development, integration testing, or prototyping, you need a separate tool. This guide shows you the fastest way to get a Bruno API client mock server workflow up and running.

# Does Bruno Have a Built-in Mock Server?

No. Bruno is an API client, not a mock server. It's designed for:

• • Sending HTTP requests (GET, POST, PUT, DELETE, etc.)
• • Managing API collections as plain text .bru files
• • Storing collections locally in your Git repository
• • Running requests with environments and variables

Bruno intentionally stays lean. It doesn't try to be an all-in-one platform like Postman. This is a feature, not a limitation — it means Bruno remains fast, privacy-focused, and open source.

However, this means if you need mock APIs (simulated endpoints that return fake data), you'll need a separate mock server tool.

# The Problem: Mock Server for Bruno Users

Here's the typical scenario:

1. • Your team is designing a new API using an OpenAPI specification
2. • The backend isn't built yet (or is under heavy development)
3. • Your frontend developers need working API endpoints to build against
4. • You want to use Bruno as your API client (not Postman)

Without a mock server, frontend development stalls. You could hardcode fake data in your frontend, but that's messy and doesn't test real HTTP behavior.

# The Solution: ApiNotes + Bruno

ApiNotes is a hosted mock server that generates live API endpoints from your OpenAPI specification. The key feature for Bruno users: one-click export to Bruno collections.

Here's how it works:

# Step 1: Create a Mock Server

Go to apinotes.io/mock-server and paste your OpenAPI spec (JSON or YAML). No account needed — it's completely free for anonymous use.

Click "Create Mock Server" and within seconds, every endpoint in your spec gets a live URL with realistic responses generated from your schema definitions.

# Step 2: Export to Bruno

After your mock server is created, you'll see an "Export to Bruno" button. Click it to download a .zip file containing:

• • A complete Bruno collection with all your API endpoints
• • Each endpoint configured with the correct HTTP method and path
• • The mock server base URL pre-set as the collection's base URL
• • Request headers and example bodies where applicable

# Step 3: Open in Bruno

Unzip the collection and open it in Bruno. You'll see all your endpoints ready to fire. Every request points to your live mock server URL and returns realistic responses based on your OpenAPI schema.

# Step 4: Commit to Git

Since Bruno stores collections as plain .bru files, you can commit the entire collection to your Git repository. Every developer on your team gets the same mock testing setup by pulling the repo.

# Why This Workflow Beats Alternatives

# vs. Postman Mock Server

Postman's mock server requires:

• • A Postman account
• • Creating a collection
• • Manually saving examples for each request
• • Per-user pricing ($14-$49/user/month for higher limits)

ApiNotes + Bruno requires:

• • No account (anonymous mocks available)
• • Paste your OpenAPI spec once
• • All endpoints mocked automatically from schemas
• • Flat pricing ($8/month, not per-user)
• • Export to Bruno for local, offline testing

# vs. WireMock / Mockoon

WireMock and Mockoon are powerful self-hosted mock tools, but they require:

• • Installing and running a local server
• • Manually configuring mock rules and responses
• • Managing a separate server process

ApiNotes gives you hosted mock URLs without running anything locally. And the Bruno export means you still have a local testing experience.

# vs. Hardcoding Mock Data

Hardcoding fake API responses in your frontend code:

• • Doesn't test real HTTP calls
• • Requires cleanup before production
• • Doesn't validate request/response contracts
• • Is tedious to maintain as the API evolves

A proper mock server with Bruno collection files is cleaner and more realistic.

# Mock Response Generation

ApiNotes generates mock responses by reading your OpenAPI spec's:

• • examples — If you've defined response examples, those are used exactly
• • x-example — Vendor extension examples are supported
• • default values — Schema defaults are respected
• • Schema definitions — If no examples exist, realistic data is generated from property names, types, formats, and patterns

This means you get realistic responses without manually defining them — the spec is the single source of truth.

# Request Limits and Pricing

Bruno itself is completely free (MIT license). The optional Bruno Golden Edition ($19 one-time) adds features like visual Git diff but isn't needed for this workflow.

# Frequently Asked Questions

# Does Bruno API client have a mock server feature?

No. Bruno is an API client focused on sending requests and managing collections. It does not generate or host mock API endpoints. For mock server functionality, pair Bruno with a tool like ApiNotes.

# Can I export a mock server to Bruno?

Yes — ApiNotes is the only mock server platform with a built-in "Export to Bruno" feature. After creating your mock, click the button to download a complete Bruno collection.

# Is this similar to Postman's mock server?

Yes, but simpler and more spec-driven. Postman requires manual example creation per request. ApiNotes auto-generates responses from your OpenAPI spec and exports to Bruno instead of locking you into Postman's ecosystem.

# Can I use this with OpenAPI 3.0 and 3.1?

Yes. ApiNotes supports OpenAPI 3.0, OpenAPI 3.1, and Swagger 2.0 specifications in both JSON and YAML formats.

# Is the mock server URL publicly accessible?

Yes. The mock URL is a public HTTPS endpoint, which means your frontend (running on localhost or deployed anywhere) can reach it. This also works in CI/CD pipelines.

# Getting Started

1. • Open apinotes.io/mock-server
2. • Paste your OpenAPI spec
3. • Click "Create Mock Server"
4. • Click "Export to Bruno"
5. • Open the collection in Bruno and start testing

No account required. No credit card. Takes under 60 seconds.

Related resources:

• • Bruno vs ApiNotes — Full Comparison
• • Postman Mock Server vs ApiNotes
• • Free API Mock Server Generator