Norn

Version-controlled API tests for VS Code and CI

Turn API requests into tests your whole team can keep — authored and debugged in VS Code, run on every PR in CI.

.norn .nornapi .nornsql .nornenv
Built for Real API Testing

Version-controlled API tests for specs, flows, and CI

Define version-controlled API tests that combine requests, scripts, SQL checks, assertions, and environment-aware runs.

Define the contract

Turn OpenAPI into workflow inputs

Import endpoints and schemas once, then reuse the same API definitions across every workflow.

swagger "https://petstore.swagger.io/v2/swagger.json"

endpoints
    GetPetById: GET {{baseUrl}}/pet/{petId}
    PlaceOrder: POST {{baseUrl}}/store/order
end endpoints
Automate the journey

Orchestrate APIs, scripts, and SQL

Create data, call services, run helpers, query databases, and carry values forward in one readable sequence.

sequence VerifyOrderFlow
    run bash ./scripts/seed-db.sh
    var data = run js ./scripts/sign.js {{payload}}
    var row = run sql FindOrder(data.id)
end sequence
Operationalize it

Run the same workflows anywhere

Use VS Code while building, then run the same workflow files from the CLI in CI.

norn tests/ --env prelive
norn tests/ --junit results/junit.xml

Contracts, validations, and coverage stay connected in the same version-controlled tests.

Development Loop

Build once, run everywhere

Norn keeps API tests close to development. Use VS Code when you are shaping a flow, then run the same version-controlled files from the CLI when the tests become part of your release process.

01

Build in VS Code

Author the workflow beside your code with endpoints, environments, assertions, SQL checks, and helper scripts.

02

Run real flows

Create data, call services, capture response values, and pass them into the next step without switching tools.

03

Validate the result

Check status codes, payloads, schemas, timings, and database state so the workflow produces a clear signal.

04

Promote to CI

Run the same .norn files from the CLI with environment selection, JUnit output, and HTML reports.

orders.workflow.norn VS Code
test sequence CheckoutWorkflow
    run bash ./scripts/seed-cart.sh

    POST {{baseUrl}}/orders
    {
        "cartId": "{{cartId}}"
    }

    assert $1.status == 201
    var orderId = $1.body.id

    run sql FindOrder(orderId)
    assert $2.rows[0].status == "created"
end sequence
Run Results Passed
Norn run results panel showing a successful workflow
OpenAPI Coverage Contract
Norn OpenAPI coverage view
CI Release Gate CLI
Norn CLI run in a release pipeline
Not Just A REST Client

REST clients send requests. Norn turns them into tests you keep.

Keep request exploration, test automation, validation, database checks, and CI execution in the same developer-owned, version-controlled files.

Typical REST client
Norn API tests
Sends individual requests
Automates multi-step workflows with variables and captured responses
Keeps examples separate from release checks
Turns the same workflow into a local run, VS Code test, and CI gate
Usually stops at the HTTP response
Validates response bodies, contracts, timings, and database state
Requires manual environment and setup discipline
Uses reusable API definitions, .nornenv files, SQL operations, and scripts
Useful for exploration
Useful for exploration, regression coverage, and release confidence

See Norn in Action

Watch a quick walkthrough, then scan the example below to see how Norn turns API steps into version-controlled tests

Workflow Run

Prefer a quick glance first? The example below shows the shape of a typical Norn workflow.

example.norn
test sequence UserWorkflow    # Create a new user    POST {{baseUrl}}/users    {        "name": "Alice",        "email": "alice@example.com"    }    assert $1.status == 201    var userId = $1.body.id    # Verify the user was created    GET {{baseUrl}}/users/{{userId}}    assert $2.body.name == "Alice"end sequence
UserWorkflow 124ms
1. $1 201 Created 67ms
2. assert $1.status == 201
3. $2 200 OK 52ms
4. assert $2.body.name == "Alice"

Everything You Need

Orchestration, validation, environments, and CI for API tests

Workflow Sequences

Automate multi-step API workflows with response capture, variables, and references to previous steps using $1 and $2.

Validation Gates

Turn every workflow into a release signal with equality, contains, regex, type, existence, schema, and timing checks.

Environments

Run the same automation against dev, staging, prelive, or production using .nornenv variables instead of editing requests.

CLI for CI/CD

Run workflow suites from local scripts and pipelines with JUnit and HTML reports for automated release gates.

Test Explorer

Run and debug workflow sequences from VS Code's Testing sidebar with status codes, timings, and failure details.

API Coverage

Keep automated workflow coverage tied to Swagger/OpenAPI endpoints and expected response codes.

Four File Types,
Complete Control

Organize API tests with purpose-built file types that keep flows, SQL, environments, and reusable definitions cleanly separated.

.norn

Workflow Files

HTTP steps, sequences, assertions, and automation logic. This is where your workflows live.

.nornapi

API Definitions

Reusable headers, endpoints, and Swagger imports. Define once, use everywhere.

.nornsql

SQL Operations

Named queries and commands that let workflows verify state in Postgres, SQL Server, or custom adapters.

.nornenv

Environments

Variables for dev, staging, prelive, and production. Switch contexts without changing workflows.

Questions

Version-controlled API testing, without the mystery

Is Norn a Postman or Insomnia replacement?

Norn can send API requests, but the product is aimed at version-controlled API testing: sequences, assertions, environments, SQL checks, and CLI execution.

Can Norn run without VS Code?

Yes. You can build and debug workflows in VS Code, then run the same files with the Norn CLI in local scripts or CI.

How does OpenAPI fit in?

Norn can import Swagger/OpenAPI definitions so endpoints, schemas, and coverage stay tied to the same contract your team already maintains.

Can workflows verify backend state?

Yes. Norn supports named SQL operations, with built-in Postgres and SQL Server support plus custom adapters when needed.

What makes a Norn workflow useful in CI?

Workflows produce direct pass/fail signals through assertions and can emit JUnit and HTML reports, making them suitable for automated release gates.

Ready to Put Your API Tests in the Repo?

Install Norn from the VS Code Marketplace or book a demo to see how it fits your API testing.