Documentation

Mockondo is a native desktop application for macOS (Windows and Linux support coming soon). No configuration files, no terminal commands just download, open, and start mocking.

Installation

Download the latest release from GitHub Releases and open the .zip file on macOS.

Requires macOS 10.15 or later. Apple Silicon (M1/M2/M3) is supported.

Create your first project

1. Open Mockondo and click New Project.
2. Set a name, host (default: Project 1), and port (e.g. 3001).
3. Add an HTTP endpoint, configure the response, and click Start Server.
4. Your mock API is now live at http://[your-local-IP]:3001.

Define HTTP endpoints with custom methods, paths, response bodies, status codes, and headers. No backend code required.

Supported methods

GET POST PUT PATCH DELETE

Response configuration

Conditional Rules

Route different responses based on incoming request attributes. Rules are evaluated top-to-bottom and the first match wins.

Simulate real-time bidirectional communication chat apps, live notifications, stock tickers, collaborative tools, and more.

Endpoint configuration

Message matching

Define rules to respond to specific incoming messages. Matching supports:

• Exact match responds when message equals the rule value exactly
• Contains responds when message contains the rule value
• Regex responds when message matches a regular expression pattern

Scheduled push

Configure a push interval (in milliseconds) to have Mockondo automatically broadcast a message to all connected clients at regular intervals. Useful for simulating real-time data feeds.

{
  "symbol": "${random.word}",
  "price": ${math.random(100, 500)},
  "change": ${math.random(-5, 5)}
}

Mockondo includes an S3-compatible local object storage server. Use it to test file uploads, downloads, and bucket operations without any cloud setup.

Features

• Create and manage multiple buckets
• Upload and download files (any type)
• Presigned URL generation
• Automatic binding to your local Wi-Fi IP accessible across devices on the same network
• Compatible with any AWS S3 SDK (set endpoint to the Mockondo address)

Connecting with AWS SDK

import { S3Client } from "@aws-sdk/client-s3";

const client = new S3Client({
  region: "us-east-1",
  endpoint: "http:// [your-local-IP]:9000", // Mockondo S3 port
  forcePathStyle: true,
  credentials: {
    accessKeyId: "mockondo",
    secretAccessKey: "mockondo",
  },
});

Inject dynamic values into your response bodies using the ${...} interpolation syntax. Works in HTTP responses, WebSocket messages, and HTTP client request bodies.

random.*

request.*

customdata.*

Reference user-defined data lists. Create a list named cities with values, then use:

${customdata.cities.random}   // picks a random item
${customdata.cities.0}        // picks by index

math.*

Evaluate arithmetic expressions inline:

${math.2+2}          // → 4
${math.2*2}          // → 4

pagination.*

Access pagination context variables when building paginated responses:

Full example

{
  "id": "${random.uuid}",
  "name": "${random.name}",
  "email": "${random.email}",
  "role": "${request.body.role}",
  "city": "${customdata.cities.random}",
  "score": ${math.random(0, 100)},
  "token": "${random.jwt}"
}

{
  "total": 100,
  "data": ${pagination.data}
}

Generate paginated API responses from a single item template. Mockondo handles the pagination math and wraps items in your configured envelope format.

Configuration

Example request

GET /users?page=2&limit=10

Returns items 11–20 of the total set, with pagination metadata.

Example config

Normal response

{
  "total": 100,
  "data": ${pagination.data}
}

Pagination Data (data from ${pagination.data})

{
  "id": "${random.uuid}",
  "name": "${random.name}",
  "email": "${random.email}",
  "role": "${request.body.role}",
  "city": "${customdata.cities.random}",
  "score": ${math.random(0, 100)},
  "token": "${random.jwt}"
}

Mockondo includes a full-featured built-in HTTP client (a Postman alternative) and a WebSocket client so you can test your mock servers without leaving the app.

HTTP Client features

• All HTTP methods (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS)
• Request headers management
• Body types: JSON, form data, raw text, binary
• cURL import and export
• Full interpolation support in URL, headers, and body
• Response viewer with syntax highlighting

WebSocket Client features

• Connect to any WebSocket server (including your Mockondo mock)
• Send messages with interpolation support
• Full conversation log with timestamps
• Auto-reconnect support

Import existing API specs to instantly scaffold mock endpoints, or export your Mockondo configuration as a standard spec to share with your team.

OpenAPI 3.0.3

• Import parse an OpenAPI 3.0.3 YAML/JSON file and auto-generate HTTP endpoints with example responses
• Export export your mock definitions as a valid OpenAPI 3.0.3 document (interpolation variables are resolved to examples)

AsyncAPI 2.6

• Import parse an AsyncAPI 2.6 spec and generate WebSocket endpoints with message definitions
• Export export WebSocket mock configurations as an AsyncAPI 2.6 document

Paste any JSON payload and Mockondo will generate strongly-typed model classes in your language of choice.

Supported languages

TypeScript Dart Kotlin Swift

Example

Input JSON:

{
  "id": "abc-123",
  "name": "Alice",
  "email": "alice@example.com",
  "isActive": true
}

Generated TypeScript:

interface User {
  id: string;
  name: string;
  email: string;
  isActive: boolean;
}

Describe what you need in plain language and let Mockondo's AI agent generate your mock server configuration automatically.

What the AI can do

• Generate complete mock projects from a plain-language description
• Create complex HTTP endpoints with realistic response data
• Set up WebSocket servers with message rules
• Apply appropriate interpolation variables automatically
• Configure conditional rules based on described behavior

Example prompts

"Create a REST API for an e-commerce app with products, cart, and orders endpoints"

"Build a chat WebSocket server that broadcasts messages to all clients"

"Generate a paginated users endpoint with 500 total users"

Mockondo runs entirely on your machine. No cloud, no account, no internet required your mock servers start instantly and stay private.

Why it matters

• Work on flights, trains, or anywhere without Wi-Fi
• No data ever leaves your device (sensitive projects stay private)
• Zero latency between requests servers respond at local speed
• All project data is stored locally and persists between sessions

Full state export

Save your entire Mockondo workspace all projects, endpoints, client requests, and S3 config to a single JSON file. Share it with teammates or restore it on another machine.