Mock Server

Create mock API endpoints with custom responses, status codes, and headers. Perfect for frontend development, API testing, and prototyping before backend implementation.

Features

• All HTTP Methods: Support for GET, POST, PUT, DELETE, and PATCH
• Custom Responses: Define exactly what your endpoint returns
• Status Codes: Configure any HTTP status code (200, 404, 500, etc.)
• Custom Headers: Add custom headers to responses
• Request Logging: View incoming request data including headers, body, and query params (paid plans)
• CDN Delivery: Responses served via Google Cloud Storage CDN
• Usage Analytics: Track endpoint access counts
• CORS Support: Built-in CORS headers for frontend integration

Request Logging (REQUEST Tab)

The REQUEST tab allows you to inspect incoming requests to your mock endpoints. This is invaluable for debugging integrations, verifying webhook payloads, and understanding how clients interact with your mocked APIs.

What's Captured

For each incoming request, the following data is logged and available in the REQUEST tab:

• Request Body: Full JSON or form data payload sent by the client
• Query Parameters: URL query string parameters (?key=value)
• Headers: All HTTP headers sent with the request
• HTTP Method: The method used (GET, POST, PUT, etc.)
• Timestamp: When the request was received
• Client IP: The originating IP address

Accessing Request Logs

1. Navigate to VerveKit → Mock Server in your dashboard
2. Click on an endpoint to view its details
3. Select the REQUEST tab
4. View the most recent request data captured for that endpoint

Use Cases

Creating a Mock Endpoint

Via Dashboard

1. Sign in to your APIVerve Dashboard
2. Navigate to VerveKit → Mock Server
3. Click "Create New Endpoint"
4. Configure your endpoint:
   • Name: Descriptive name for the endpoint
   • HTTP Method: GET, POST, PUT, DELETE, or PATCH
   • Status Code: HTTP status code to return (e.g., 200, 404, 500)
   • Response Body: JSON or text response
   • Headers: Optional custom headers
5. Click "Save" to create your endpoint

Configuration Options

HTTP Methods

Choose from the following HTTP methods:

• GET: Retrieve data (most common for mock endpoints)
• POST: Submit data (simulate resource creation)
• PUT: Update data (simulate full resource update)
• PATCH: Partial update (simulate partial resource update)
• DELETE: Delete data (simulate resource deletion)

Status Codes

Common status codes you can configure:

• 200: OK - Successful request
• 201: Created - Resource created successfully
• 400: Bad Request - Invalid request data
• 401: Unauthorized - Authentication required
• 403: Forbidden - Access denied
• 404: Not Found - Resource doesn't exist
• 500: Internal Server Error - Server error
• 503: Service Unavailable - Service temporarily down

Custom Headers

Add custom headers to your responses:

{
  "Content-Type": "application/json",
  "X-Custom-Header": "CustomValue",
  "Cache-Control": "no-cache"
}

Accessing Your Endpoint

Once created, your mock endpoint is immediately available:

https://api.apiverve.com/v1/mockserver/{serverId}/{path}

Authentication

Include your API key in the request header:

• Header: x-api-key
• Location: HTTP headers
• Required: Yes

x-api-key: YOUR_API_KEY

HTTP Method

The request must match the configured HTTP method for the endpoint.

Code Examples

GET Request (cURL)

curl "https://api.apiverve.com/v1/mockserver/abc123/users" \
  -H "x-api-key: YOUR_API_KEY"

POST Request (cURL)

curl -X POST "https://api.apiverve.com/v1/mockserver/abc123/users" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"key": "value"}'

JavaScript (Fetch API)

const apiKey = 'YOUR_API_KEY';
const serverId = 'abc123';
const path = '/users';

fetch(`https://api.apiverve.com/v1/mockserver/${serverId}${path}`, {
  headers: {
    'x-api-key': apiKey
  }
})
  .then(response => {
    console.log('Status:', response.status);
    return response.json();
  })
  .then(data => {
    console.log('Response:', data);
  })
  .catch(error => {
    console.error('Error:', error);
  });

JavaScript (POST with Fetch)

const apiKey = 'YOUR_API_KEY';
const serverId = 'abc123';
const path = '/users';

fetch(`https://api.apiverve.com/v1/mockserver/${serverId}${path}`, {
  method: 'POST',
  headers: {
    'x-api-key': apiKey,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ key: 'value' })
})
  .then(response => response.json())
  .then(data => console.log('Response:', data))
  .catch(error => console.error('Error:', error));

Python (requests)

import requests

api_key = 'YOUR_API_KEY'
server_id = 'abc123'
path = '/users'
url = f'https://api.apiverve.com/v1/mockserver/{server_id}{path}'
headers = {'x-api-key': api_key}

# GET request
response = requests.get(url, headers=headers)
print(f'Status: {response.status_code}')
print(f'Response: {response.json()}')

# POST request
response = requests.post(url, headers=headers, json={'key': 'value'})
print(f'Response: {response.json()}')

Node.js (axios)

const axios = require('axios');

const apiKey = 'YOUR_API_KEY';
const serverId = 'abc123';
const path = '/users';
const url = `https://api.apiverve.com/v1/mockserver/${serverId}${path}`;
const headers = { 'x-api-key': apiKey };

// GET request
axios.get(url, { headers })
  .then(response => {
    console.log('Status:', response.status);
    console.log('Data:', response.data);
  })
  .catch(error => console.error('Error:', error));

// POST request
axios.post(url, { key: 'value' }, { headers })
  .then(response => console.log('Data:', response.data))
  .catch(error => console.error('Error:', error));

Example Scenarios

Success Response (200)

Mock a successful API response:

{
  "status": "success",
  "data": {
    "id": 123,
    "name": "Product Name",
    "price": 29.99,
    "inStock": true
  },
  "message": "Product retrieved successfully"
}

Error Response (404)

Mock a resource not found error:

{
  "status": "error",
  "code": "NOT_FOUND",
  "message": "The requested resource was not found",
  "timestamp": "2024-01-01T12:00:00Z"
}

Validation Error (400)

Mock a validation error:

{
  "status": "error",
  "code": "VALIDATION_ERROR",
  "message": "Invalid request data",
  "errors": [
    {
      "field": "email",
      "message": "Email is required"
    },
    {
      "field": "password",
      "message": "Password must be at least 8 characters"
    }
  ]
}

Server Error (500)

Mock a server error:

{
  "status": "error",
  "code": "INTERNAL_ERROR",
  "message": "An unexpected error occurred",
  "requestId": "abc-123-def"
}

Rate Limits & Pricing

Free Plan

• Daily Limit: 100 requests per endpoint per day
• Reset: Daily at midnight UTC
• Endpoints: Unlimited endpoints, 1MB per response max

Paid Plans

• Requests: Unlimited (based on your API credit balance)
• Credit Cost: Requests do NOT consume credits
• Endpoints: Unlimited endpoints, 1MB per response max

Managing Your Endpoints

Edit Endpoint

Update your mock endpoint configuration:

1. Navigate to Mock Server in your dashboard
2. Click Edit next to your endpoint
3. Modify method, status code, response, or headers
4. Click Save

Delete Endpoint

1. Navigate to Mock Server in your dashboard
2. Click Delete next to your endpoint
3. Confirm the deletion

View Analytics

Track usage for each endpoint:

• Total Access Count: Total number of requests
• Daily Access Count: Requests today (for free plan tracking)
• HTTP Method: Configured method
• Status Code: Configured status code

Error Responses

400 Bad Request

{
  "status": "error",
  "error": "Endpoint ID is required"
}

404 Not Found

{
  "status": "error",
  "error": "Mock endpoint not found"
}

405 Method Not Allowed

{
  "status": "error",
  "error": "Method not allowed. Expected POST, got GET"
}

429 Too Many Requests

{
  "status": "error",
  "error": "Daily access limit exceeded (100 requests per day for free plan)",
  "requiresUpgrade": true
}

500 Internal Server Error

{
  "status": "error",
  "error": "Failed to fetch mock response"
}

Best Practices

• Realistic Responses: Create responses that match your actual API structure
• Status Codes: Use appropriate status codes for different scenarios
• Headers: Include relevant headers (Content-Type, Cache-Control, etc.)
• Error Testing: Create endpoints with error responses to test error handling
• Documentation: Use descriptive names to document the purpose of each endpoint
• Size Limit: Keep responses under 1MB for optimal performance
• Method Matching: Ensure your client uses the correct HTTP method

Need Help?

• VerveKit Overview
• Quick Start Guide
• Authentication Documentation
• Mock Server Dashboard
• Contact Support