What's in the generated JSON config, exactly?

Each route becomes an object with method, path, authRequired (boolean), and rateLimitPerMinute (a number, or null if you left the rate limit field blank), collected under a top-level "routes" array, a shape close to what many API gateway or route-registration configs expect.

What does the Markdown docs stub contain?

One section per route (### METHOD /path) listing whether authentication is required and the configured rate limit, giving you a starting documentation skeleton to expand with request/response details for each endpoint.

Can I leave the rate limit blank?

Yes. A blank rate limit produces rateLimitPerMinute: null in the JSON and "Rate limit: none" in the docs stub, meaning that route has no configured limit in this output.

Does this generate actual server code or middleware?

No. It generates a structured config and a documentation stub you can feed into your own route-registration logic, API gateway config, or docs site; it doesn't generate framework-specific route handlers.

REST API Config Generator - Route Config + Docs Stub

Overview

Introduction

Before an API even has a formal spec, it's common to sketch out the route list first: which methods and paths exist, which need auth, and what rate limits apply.

This tool turns that sketch into both a structured JSON config and a Markdown documentation starting point, entirely in your browser.

What Is REST API Config Generator?

A route-config generator that takes a repeatable list of method/path/auth/rate-limit rows and produces a structured JSON config plus a per-route Markdown docs stub.

It's part of this site's API Tools collection, meant as an early-stage scaffolding tool rather than a full OpenAPI or Swagger document generator.

How REST API Config Generator Works

Each route row is validated (a path starting with /, and if provided, a positive whole-number rate limit) and converted into a JSON object with method, path, authRequired, and rateLimitPerMinute fields.

The same routes are then rendered a second time as Markdown headings, one per route, each listing its auth requirement and rate limit in plain language, separated from the JSON block by a horizontal rule.

When To Use REST API Config Generator

Use it early when planning a new API's route surface, before committing to a full OpenAPI specification.

It's also useful for producing a quick internal reference of which routes require authentication and what rate limits apply, without writing a full spec.

Often used alongside OpenAPI Generator and Swagger YAML Generator.

Features

Advantages

Produces both a machine-readable config and human-readable docs from one shared input, so they never drift out of sync while you're still sketching the API.
Validates rate limits and paths defensively, catching an obviously malformed route before it reaches a config file.
Handles routes with no rate limit gracefully, representing it explicitly as null rather than omitting the field.

Limitations

Doesn't generate a full OpenAPI or Swagger document with schemas and examples; use the OpenAPI Generator or Swagger YAML Generator for that.
The four supported methods (GET/POST/PUT/DELETE) don't include PATCH, HEAD, or OPTIONS.
Rate limits are a single requests-per-minute number; more nuanced rate-limit policies (burst limits, per-user tiers) aren't modeled.

Examples

Two routes, one requiring auth

Input

routes: [{method: GET, path: /users, authRequired: false, rateLimit: 100}, {method: POST, path: /users, authRequired: true, rateLimit: 20}]

Output

{
  "routes": [
    { "method": "GET", "path": "/users", "authRequired": false, "rateLimitPerMinute": 100 },
    { "method": "POST", "path": "/users", "authRequired": true, "rateLimitPerMinute": 20 }
  ]
}

---

# API Route Documentation

### GET /users

- Auth required: No
- Rate limit: 100 requests/minute

### POST /users

- Auth required: Yes
- Rate limit: 20 requests/minute

Each route appears once in the JSON config and once more as its own Markdown section in the docs stub.

Best Practices & Notes

Best Practices

Set a rate limit on any route that accepts writes (POST/PUT/DELETE) even if reads are left unlimited, since write endpoints are usually the more expensive and abuse-prone ones.
Mark authRequired accurately for every route before wiring this config into real middleware; a false negative here means an unauthenticated route in production.
Treat the Markdown output as a starting skeleton, not finished documentation — add request/response body details, error codes, and examples before publishing it externally.

Developer Notes

The JSON and Markdown outputs are generated from the exact same validated route list in a single pass, so there's no risk of the two representations describing different routes; rateLimitPerMinute is emitted as a JSON null (not an empty string or omitted key) when no limit is set, which keeps the field's type consistent for any downstream parser.

REST API Config Generator Use Cases

Sketching out a new API's route surface, auth requirements, and rate limits before writing a full OpenAPI spec
Generating a quick internal reference doc listing which endpoints require authentication
Producing a starting JSON config for a hand-rolled route registration or API gateway setup

Common Mistakes

Treating the generated Markdown as complete API documentation; it's a structural stub, not a substitute for documenting request/response shapes and error handling.
Forgetting to set a rate limit on write-heavy routes and only rate-limiting reads.

Tips

Move to the OpenAPI Generator once your route list stabilizes, since a full OpenAPI document adds request/response schemas that this lightweight config intentionally leaves out.

REST API Config Generator