Aura 51 · Contour Book a call

For CTOs and lead devs

Your API has no docs. In 48 hours, it does.

A complete OpenAPI spec and typed TypeScript & Python SDKs, rebuilt from a session of your app that you authorize us to observe. Your team integrates without guesswork. Your source code stays with you.

Not ready yet? Try the free version, 100 % in your browser: HAR → OpenAPI + SDK →

  • 20 min, firm quote at the end
  • Written authorization before any capture
  • Zero access to your source code
session-staging.har Example
Observed POST /v2/orders 201
authorization: Bearer ••••••••masked
{
  "customer_id": "cus_8f2a",
  "items": [{ "sku": "BX-12", "qty": 2 }],
  "coupon": null
}
Generated spec openapi.yaml
OrderCreate:
  type: object
  required: [customer_id, items]  # seen 14/14
  properties:
    customer_id: { type: string }
    items:
      type: array
      items:
        $ref: "#/components/schemas/LineItem"
    coupon:
      type: [string, "null"]  # null 9×/14
Hover a fieldTap a field: every rule in the spec traces back to what was observed.

Three situations where missing docs cost you.

  • The dev who wrote it has left.

    Nobody knows what /v1/sync returns anymore, and the whole team is afraid to touch it.

  • A new dev starts on Monday.

    Without docs, they spend their first week reading code. With the spec, they read the contract in an hour.

  • Your mobile app has to plug into it.

    The typed SDK replaces trial and error in Postman and screenshots passed around on Slack.

Three steps, two business days.

Contour reads your session's traffic, masks the secrets, then infers the API contract with a confidence score for every operation.

  1. Day 0

    You sign the agreement

    One page: which app, which environment, for how long. Nothing is captured before you sign.

  2. Day 0 to day 2

    We compile your session

    You export a session of your app (a HAR file, a few clicks in the browser) or open a test account for us. Contour groups the calls and infers the schemas.

  3. Day 2

    You get the pack

    Spec, SDKs and confidence report. You commit it, and your team uses it the same day.

What lands in your repo.

Four files, readable by your devs and by your tools. A preview of a sample pack, built on a fictional orders API.

contour-pack/openapi.yaml
openapi: 3.1.0
info:
  title: Orders API (internal)
  version: 2.0.0
  x-generated-by: contour
servers:
  - url: https://staging.example.com
paths:
  /v2/orders:
    post:
      operationId: createOrder
      summary: Creates an order
      security: [{ bearerAuth: [] }]
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/OrderCreate"
      responses:
        "201": { $ref: "#/components/responses/Order" }
        "422": { $ref: "#/components/responses/Invalid" }
      x-confidence: 0.96  # 14 calls observed
  # … 23 more operations

Formats: OpenAPI 3.1, TypeScript 5, Python 3.11+. The spec opens as is in Swagger UI, Redoc or Postman.

Your code stays with you.

Contour only reads the HTTP traffic of a session you authorize. The simplest setup: your staging environment, a test account, fictional data.

What we observe

  • Requests and responses from the authorized session
  • Only the flows you choose to show
  • Nothing else, and nothing before you sign

What we never touch

  • Your source code and your repo
  • Your database
  • Your infrastructure and servers

Legal framework

Interoperability only, on an API you own or are authorized to integrate. Never source code.

Authorization first

A signed written agreement before any capture. It protects you as much as it protects us.

Secrets masked

Tokens, credentials and personal data are removed before any analysis by a model.

A fixed price. No surprises.

We scope it together on the call, and you leave with a firm quote.

Want to see it before a call? The free tool compiles your HAR locally, in seconds. · The compiler is open-source

Spec only

To document what exists and onboard your devs.

$1,750

  • Complete OpenAPI spec
  • Confidence report
  • Delivered in 48 hours
Book the call
Recommended

Spec + SDK

So an app or a new dev can plug in right away.

$2,900

  • Everything in Spec only
  • Typed TypeScript client
  • Typed Python client
  • Example calls
Book the call

Spec + SDK + integration

So we wire it into your app with your team.

from$3,500

  • Everything in Spec + SDK
  • Integration into your app
  • Handover session
Book the call

Not sure which pack fits? We'll decide together on the call.

The questions a CTO asks before signing.

Is this legal?

The framework is built for it: we document the interface of an API you own, or that your contract authorizes you to integrate, from sessions you have the right to observe. No circumvention of protections, no access to source code, and a signed written agreement before any capture. Unsure about your rights? We settle it on the call, before any quote.

Is our data exposed?

The safest option, and the one we recommend: your staging environment, a test account, fictional data. Nothing real leaves. If you work against production, tokens, credentials and personal data are masked before any analysis by a model, and the report lists everything that was masked.

48 hours, really?

Two business days, counted from the signed agreement and the session you send. That's the right order of magnitude for most internal APIs. If yours is larger, we tell you on the call and the quote states it in black and white.

What do we need to provide?

Three things: the signed authorization agreement (we send you the template), a session that walks through your app's key screens, as a HAR export or through a test account, and twenty minutes to tell us what matters. That's it.

What about an endpoint missing from the session?

It won't appear in the spec: we don't guess. The confidence report lists what was seen, how many times, and what's left to cover. One additional session is enough to fill the gaps.

Why not just read the code?

Because you shouldn't have to open your repo to a contractor. And because the session shows what your API actually does, not what the code was supposed to do.

What happens on the call?

You describe the API that's blocking you. We assess the scope with you and tell you whether it's doable. If it is, you leave with a firm quote. The call is free, with no commitment. Book the 20 minutes

Tell us which API is blocking you.

Twenty minutes. If it's doable, you leave with a firm quote. If not, you'll know why.

Book the scoping call.

20 minutes on video. Tell us which API is blocking you and when you're free: David Amor proposes a slot within one business day, with a firm quote at the end of the call.

Your request goes straight to David Amor. Nothing is shared with third parties.