Skip to main content
If your API has an OpenAPI spec, you can import it into Reqflo to generate request templates without building them by hand. Each endpoint in the spec becomes a template in the library — method, URL, parameters, headers, and body shape already filled in.

​
When to use it

Import from OpenAPI when:
  • You’re onboarding a new API surface and want templates for every endpoint immediately.
  • Your team maintains an up-to-date spec and wants the template library to stay in sync.
  • You’d rather review and adjust generated templates than write them from scratch.
It’s fine to import a large spec and only wire up the endpoints you actually need right now. Unused templates sit in the library without affecting anything.

​
Key concepts

  • OpenAPI 3.x and 2.x (Swagger) — both formats are supported for import.
  • One template per operation — each operationId (or method + path combination if no operationId is set) becomes one template.
  • Parameter mapping — path, query, and header parameters in the spec map directly to template value declarations. Request body schemas are parsed and their fields become body value declarations.
  • Example values — if the spec includes example or examples fields, Reqflo uses them to pre-populate template example values.
  • Tags — OpenAPI operation tags become template tags in the library, so your templates are organized the same way your spec is.
  • Incremental re-import — re-importing an updated spec refreshes templates that have changed. Templates you’ve manually edited are flagged so you can review differences before applying changes.

​
How it works

1

Open the template library

Navigate to the Request template library and select Import from OpenAPI.
2

Provide your spec

Paste a URL pointing to your spec (e.g., a hosted openapi.yaml or a raw GitHub URL), or upload a file directly. Reqflo accepts .yaml, .yml, and .json.
3

Review the import preview

Reqflo parses the spec and shows you what it found: how many operations were detected, how they’ll be tagged, and any operations it couldn’t parse cleanly. Deselect any operations you don’t want to import.
4

Confirm and import

Confirm the import. Templates appear in the library immediately, organized by tag. Review them and adjust any field that the automatic mapping didn’t capture correctly.

​
Examples

Importing from a hosted spec URL If your spec is served at https://api.example.com/openapi.yaml, paste that URL into the import dialog. Reqflo fetches and parses it on the spot. What a generated template looks like Given this OpenAPI operation: 
paths:
  /v2/payments/{paymentId}:
    get:
      operationId: getPayment
      summary: Get a payment by ID
      tags:
        - payments
      parameters:
        - name: paymentId
          in: path
          required: true
          schema:
            type: string
          example: pmt_01HXYZ
Reqflo generates: 
name: Get payment
method: GET
url: /v2/payments/:paymentId
tags:
  - payments
values:
  - name: paymentId
    in: path
    required: true
    example: pmt_01HXYZ
Handling missing operationId If an operation has no operationId, Reqflo generates a name from the method and path — for example, GET /v2/payments/{paymentId} becomes Get v2 payments paymentId. You can rename it in the library after import.
After importing, scan the generated templates for Authorization or API-key header parameters. The spec usually marks them as required but won’t know they should be secret references. Update those value declarations to recommended_source: secret so that anyone configuring a step gets the right nudge.

Request template library

Manage and organize all your templates in one place.

HTTP request templates

The full shape of a request template and how its fields map to a real HTTP request.

Template values

How templates declare the values they need and recommend configuration.

Secrets management

Configure secret references so sensitive values are never exposed.