More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    API Docs & SDK Generator

    1

    Turn curl commands, JSON samples or endpoint notes into production OpenAPI 3.1 specs, clean Markdown docs and ready-to-use TypeScript/Python clients

    $14

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    API Docs & SDK Generator

    API Docs & SDK Generator

    Example session with this skill installed

    Document this API and generate a TypeScript client from these curls and sample responses:

    curl -X GET https://api.example.com/v1/users
    -H "Authorization: Bearer sk_live_abc123"

    Response 200:

    {
      "data": [
        {
          "id": "usr_01HXYZ",
          "email": "alice@acme.com",
          "name": "Alice Chen",
          "created_at": "2026-07-12T09:14:22Z",
          "role": "admin"
        }
      ],
      "meta": {
        "page": 1,
        "per_page": 20,
        "total": 47
      }
    }
    

    curl -X POST https://api.example.com/v1/users
    -H "Authorization: Bearer sk_live_abc123"
    -H "Content-Type: application/json"
    -d '{"email":"bob@acme.com","name":"Bob Rivera","role":"member"}'

    Response 201:

    {
      "id": "usr_01HABC",
      "email": "bob@acme.com",
      "name": "Bob Rivera",
      "created_at": "2026-09-01T07:30:11Z",
      "role": "member"
    }
    

    Error 422:

    {
      "error": {
        "code": "validation_error",
        "message": "Email already registered",
        "param": "email"
      }
    }
    
    • Read your context and instructions
    • Compiled the api docs

    Summary

    Generated a complete OpenAPI 3.1 specification, clean Markdown reference, and a typed TypeScript client from the provided curls and sample responses. All schemas are conservative — only fields present in the samples were included.


    1. OpenAPI 3.1 Specification (openapi.yaml)

    openapi: 3.1.0
    info:
      title: Example Users API
      version: 1.0.0
      description: User management API with pagination and role-based access.
    servers:
      - url: https://api.example.com/v1
        description: Production
    paths:
      /users:
        get:
          operationId: listUsers
          summary: List users
          tags: [Users]
          security:
            - BearerAuth: []
          parameters:
            - name: page
              in: query
              schema:
                type: integer
                minimum: 1
                default: 1
            - name: per_page
              in: query
              schema:
                type: integer
                minimum: 1
                maximum: 100
                default: 20
          responses:
            "200":
              description: Paginated list of users
              content:
                application/json:
                  schema:
                    $ref: "#/components/schemas/PaginatedUsers"
                  example:
                    data:
                      - id: usr_01HXYZ
                        email: alice@acme.com
                        name: Alice Chen
                        created_at: "2026-07-12T09:14:22Z"
                        role: admin
                    meta:
                      page: 1
                      per_page: 20
                      total: 47
        post:
          operationId: createUser
          summary: Create a user
          tags: [Users]
          security:
            - BearerAuth: []
          requestBody:
            required: true
            content:
              application/json:
                schema:
                  $ref: "#/components/schemas/CreateUserRequest"
                example:
                  email: bob@acme.com
                  name: Bob Rivera
                  role: member
          responses:
            "201":
              description: User created
              content:
                application/json:
                  schema:
                    $ref: "#/components/schemas/User"
            "422":
              description: Validation error
              content:
                application/json:
                  schema:
                    $ref: "#/components/schemas/Error"
    components:
      securitySchemes:
        BearerAuth:
          type: http
          scheme: bearer
          bearerFormat: JWT
      schemas:
        User:
          type: object
          required: [id, email, name, created_at, role]
          properties:
            id:
              type: string
              example: usr_01HXYZ
            email:
              type: string
              format: email
            name:
              type: string
            created_at:
              type: string
              format: date-time
            role:
              type: string
              enum: [admin, member]
        CreateUserRequest:
          type: object
          required: [email, name]
          properties:
            email:
              type: string
              format: email
            name:
              type: string
            role:
              type: string
              enum: [admin, member]
              default: member
        PaginatedUsers:
          type: object
          required: [data, meta]
          properties:
            data:
              type: array
              items:
                $ref: "#/components/schemas/User"
            meta:
              type: object
              required: [page, per_page, total]
              properties:
                page:
                  type: integer
                per_page:
                  type: integer
                total:
                  type: integer
        Error:
          type: object
          required: [error]
          properties:
            error:
              type: object
              required: [code, message]
              properties:
                code:
                  type: string
                message:
                  type: string
                param:
                  type: ["string", "null"]
    

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Stop writing API documentation by hand.

    This skill takes whatever you already have — raw curl commands, sample JSON responses, endpoint lists, or messy notes — and produces three professional deliverables in one go:

    1. A complete, valid OpenAPI 3.1 specification (the single source of truth)
    2. Clean, publishable Markdown API reference documentation
    3. Lightweight, typed client code in TypeScript and Python that actually works

    Key strengths

    • Strict OpenAPI 3.1 compliance (correct nullability, operationIds, components, security schemes)
    • Never invents fields — only documents what you actually provided
    • Realistic examples + proper error documentation
    • Copy-paste ready client stubs with environment-based configuration
    • Follows current industry best practices for both documentation and SDK quality

    Ideal for

    • Backend engineers who hate writing docs
    • Teams shipping internal or public APIs
    • Indie hackers and agencies who need client SDKs fast
    • Anyone who wants their API documentation to look senior-engineer quality from day one

    Just paste your curls or JSON samples and get production-ready artifacts instead of starting from a blank page.

    • Only documents fields and status codes present in the provided samples or curls — does not invent or assume missing endpoints, parameters, or schema fields.
    • Best results when at least one successful response body and the authentication method are supplied. Very sparse input may require follow-up questions.
    • Generates lightweight TypeScript and Python client stubs (not full multi-language SDKs with advanced features like retry logic, pagination helpers, or OAuth flows).
    • Does not automatically validate the generated OpenAPI against a live server or run contract tests.
    • Complex features such as webhooks, file uploads, streaming responses, or highly polymorphic schemas need clear examples in the input to be modelled accurately.
    • Output is Markdown + OpenAPI 3.1 + basic clients. It does not produce interactive docs sites (Swagger UI / Redoc) or full SDK packages ready for npm/PyPI publication.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 2 months ago

    Permissions

    Network Access

    Allowed Hosts

    api.example.com
    Listed2 months ago

    What's inside

    Frequently Asked Questions

    You can provide raw curl commands, JSON request/response samples, or even informal endpoint descriptions. The skill will analyze these inputs to generate a structured OpenAPI 3.1 specification, Markdown documentation, and typed SDKs.

    The skill is designed to work with any AI agent platform that supports text-based skills or tools. Simply paste your raw API data into the agent's interface to receive the formatted code and documentation deliverables.

    Every generation includes three primary artifacts: a valid OpenAPI 3.1 specification (YAML/JSON), a structured Markdown API reference, and production-ready client libraries for both TypeScript and Python.

    The skill follows a 'no-hallucination' policy for schemas, meaning it strictly documents only the fields and types present in your provided samples. It adheres to the latest OpenAPI 3.1 standards, ensuring your specs are compatible with modern tools like Swagger UI and ReDoc.

    Yes, the generated TypeScript and Python clients include built-in support for environment-based configuration and standard security schemes (like Bearer tokens or API keys). They are designed as lightweight, typed stubs that you can immediately integrate into your application.

    New in APIs & Backend