Testing APIs

Sending requests

Build a request, send it once, read the answer, and keep it in a collection — or bring your requests in from Postman, OpenAPI, or curl.

The request bar

Pick the method (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS), type or paste the URL, and press Send (Ctrl+Enter).

You can paste more than a URL:

  • A curl command — for example from your browser's DevTools (Copy as cURL). The method, headers, body, and auth are filled in for you.
  • A URL with a query string — the parameters appear in the Params tab, where you can edit them one by one.
  • A path, like /orders — pick the server from the Base URL picker next to the method. See Choosing a base URL.

Press / to jump to the URL from anywhere on the page.

An address that starts with ws:// or wss:// is a WebSocket: the button says Connect, and you send and receive messages live. An answer that is an event stream shows its events as they arrive. See WebSockets and event streams.

The tabs under the request

TabWhat it does
ParamsQuery parameters (?page=2). Edit origin and path separately splits the URL into a base URL and a path.
HeadersExtra request headers, such as Accept or X-Request-Id.
AuthHow the request proves who it is: From folder (the default — see Folders), Bearer token, Basic (username and password), an API key sent in a header or the query, OAuth 2.0 (see OAuth 2.0), OAuth 1.0 (see OAuth 1.0), Digest or NTLM (see Digest and NTLM), AWS Signature (see AWS Signature), or JWT (signed here) (see JWT). Pick it from the Auth type list.
BodyFor POST, PUT and PATCH. See The body.
ChecksRules for a correct answer. See Checks.
Save valuesTake values from the answer for the next requests. See Chaining.
Run firstSend another saved request first, usually signing in. See Chaining.
Test dataRows from a CSV file as variables. See Chaining.
ExampleWhat the mock server answers for this request. See Mock server.
DocsWhat the request is for, in Markdown, with a Preview. It goes into API docs.
Load and GoalsThe performance test and its pass/fail limits. See Performance tests.
SettingsTimeout, redirects, connections, and the TLS check. See Settings.

Turn a param or header off instead of deleting it. The box at the start of each row turns it off: it stays in the list (greyed out) but isn't sent, and a param leaves the address. The box in the header row turns them all on or off. Each row can carry a Description — a note for you and your team, never sent. Bulk edit shows every row as text, one name: value a line — a line starting with // is turned off, and # note at the end is its description — so you can paste a list from Postman or your browser's DevTools.

A small badge on a tab shows what is set — for example Checks 2/3 means two of three checks passed on the last Send.

The body

Choose None, JSON, Text, Form, Form with files, File, or GraphQL.

  • JSON is checked as you type: Valid JSON, or the error and where it is. Format JSON tidies the body with neat indentation. An empty JSON body sends {}.
  • Text is sent exactly as you type it.
  • Form — fields sent the way a plain web form sends them, name=value&… (application/x-www-form-urlencoded). Many sign-in endpoints want this.
  • Form with files — fields and files together (multipart/form-data), the way a web page uploads a photo or a document. See Uploading files.
  • File — one file is the whole body, byte for byte: an image, a PDF or a ZIP an API takes as it is.
  • GraphQL — see below.

Uploading files

  1. Choose Body → Form with files.
  2. Type a field name, set its Type to File, and press Choose file. Add text fields the same way, with the type Text — the empty last row adds one.
  3. Press Send.

The app writes the form itself, with the boundary it needs, and sets the Content-Type header (one you typed on the Headers tab is replaced — a multipart boundary has to match the body). Each file goes with its name and its type (image/png, application/pdf…). For File, the content type is the file's own; type another one under the file to change it. Drag a file onto the box to choose it.

The file is copied into the app's data folder (files, up to 50 MB each). A saved request keeps working after you move or delete the original, and a data folder kept in git for the command line and CI carries its files along. On another computer, or after importing a collection, choose the file again — the app tells you which one.

  • {{variables}} and built-in values work in field names and text values, not inside files.
  • Performance tests send the files too, with test data and built-in values filled in for each request.
  • Request sent shows each file as <file: photo.png, 12.4 KB>, and the code it makes uses each language's own way to send files (curl -F, FormData, requests files=…). Put the file's path where its name is.
  • Scripts see the body as text, with each file shown by its name and size.

GraphQL

Choose Body → GraphQL on a POST request. Write the Query, the Variables as JSON, and optionally the Operation name; the app sends them the standard way, as JSON { "query": …, "variables": …, "operationName": … } — so Send, performance tests, collection runs and the command line all work the same. {{variables}} work in the query and the variables (put quotes around ones from test data).

Load schema asks the server which queries and mutations it has (the standard introspection question, with the request's address and auth) and lists them with their arguments; Find narrows the list. Click one to start from it: the app writes the query with its arguments as $variables, the fields to ask for, and the variables to fill in. If the server has introspection turned off, it says so.

Count GraphQL errors as failures (on by default): GraphQL servers usually answer 200 even when the query failed, with an errors list in the answer. With this on, such an answer fails — on Send (as a check), in collection runs, and in load reports — so a performance test can't look healthy while every query is refused.

Settings

SettingWhat it doesDefault
TimeoutHow long to wait for each answer, written like 30s or 2m. When an answer doesn't come in time, the error offers Wait up to 2m and send again (and a longer one)5m — change what new requests start with in Settings → Requests
Max redirectsHow many redirects to follow, 0–205
Reuse TCP connectionsOn behaves like a real client with keep-alive. Off makes every request pay for DNS, TCP, and TLS again.On
Skip TLS certificate checkAccepts any certificate, so test servers with self-signed or company certificates just work. Turn it off to check certificates like a browser does — for production, or to test the certificate itself. Requests saved before 0.10.0 keep their setting.On
Use the cookie jarSends cookies APIs have set (a login's session) and keeps new ones — see Cookies. Off sends only a Cookie header you add yourself.On

The tab also says which client certificate the request presents, if any — see below.

OAuth 1.0 (NetSuite and older APIs)

Some APIs sign every request with two pairs of keys instead of using a token — NetSuite's token-based authentication (TBA), and older services. Choose Auth type → OAuth 1.0:

  • Consumer key and Consumer secret — from the integration record (in NetSuite: Integration);
  • Token and Token secret — from the access token (in NetSuite: Access Token);
  • Signature method — HMAC-SHA256 (NetSuite, and most current APIs), HMAC-SHA1 for older ones, or PLAINTEXT (https only);
  • Realm — for NetSuite, your account ID, like 1234567 or 1234567_SB1 for a sandbox;
  • Send the signature in — the Header (Authorization: OAuth …, the usual) or the Query.

Each request gets a fresh nonce, timestamp and signature, over its method, address, query and — for a form body — the form fields. Performance tests sign every request the same way inside k6. Use {{variables}} for the four keys to keep them in an environment.

Digest and NTLM

Older and Windows-based services often sign in with a challenge: the server answers the first request with 401 and a challenge, and the next request proves the password without sending it.

  • Digest — Username and Password. MD5 and SHA-256 (also the -sess variants) are supported.
  • NTLM — Windows sign-in (IIS, SharePoint, internal APIs): Username, Password, and Domain. You can also type CORP\ann as the username. The app uses NTLMv2, and keeps the short sign-in exchange on one connection, as NTLM requires.

On Send you see only the final answer. In performance tests, k6 repeats the exchange for every request; those extra 401 replies are not counted as requests, so the numbers, times and error rate describe the real answers. If every request is refused, the run fails with Every request was refused with 401 — check the username, password and domain.

AWS Signature (SigV4)

For AWS endpoints that check a signature instead of a token — API Gateway with IAM auth, S3, Lambda function URLs, OpenSearch. Choose Auth type → AWS Signature and fill in:

  • Access key ID and Secret access key — from an IAM user or role;
  • Region — like eu-west-1;
  • Service — execute-api for API Gateway, s3, lambda for function URLs, es for OpenSearch;
  • Session token — only for temporary credentials (from aws sts, SSO, or a role).

Every request is signed just before it goes out, over its address, query, x-amz-* headers and body. In performance tests each request gets a fresh signature, after any test data is filled in. For S3 the body hash is sent as x-amz-content-sha256, as S3 requires. Write {{awsSecretAccessKey}} to take the key from an environment or, in CI, from --var. A signature AWS rejects comes back as 403 with AWS's own explanation in the answer.

JWT signed by the app

When an API accepts a JSON Web Token you can create yourself — signed with a shared secret or your private key — the app can sign it for you. Choose Auth type → JWT (signed here):

FieldWhat to put
AlgorithmHS256/384/512 with a shared Secret; RS256/384/512, PS256, or ES256/384/512 with a Private key (PEM) — paste it or Load a .pem file
Claims (JSON)The token's contents, like { "sub": "user-1", "aud": "orders-api" }. iat (issued now) and exp (now + Valid for) are added unless you set them. {{variables}} work here.
Valid for (minutes)How long each token lasts
Key ID (kid)Optional, for APIs that pick the key by id
Header and PrefixWhere the token goes: Authorization with Bearer by default; empty prefix sends the token alone (e.g. X-Api-Token)

Every Send signs a fresh token. In performance tests the app signs the tokens before the test starts — a series of them when the test runs longer than one token lasts, each issued when it starts being used and replaced at 80% of its life — so no request carries an expired token, and the private key never goes to the load generator. Claims are filled from the environment; values from test data don't change the claims per user.

Cookies

Like a browser, the app keeps the cookies an API sets and sends them back to it on later requests — so a site that signs in with a login form and a session cookie just works: send the login once (or make it the Run first request), and the requests after it are signed in. Cookies set on a login's redirect are kept too.

Cookies go only where they belong: to the site that set them (and its subdomains, if it said so), under their path, Secure ones only over https, and not after they expire. A cookie the server expires is forgotten.

Open See cookies on the Settings tab, or Cookies in the command palette, to see them per site — values are shortened, because a session cookie is a credential — and delete one, a site's, or all. Cookies are kept encrypted with your other secrets; session cookies (no expiry) are gone when the app closes. Turn Use the cookie jar off on a request to send only a Cookie header you add yourself.

In performance tests the session cookies go with every request (passed to k6 privately, never saved with the run), and each simulated user then keeps the cookies the API sets for it.

Client certificates (mutual TLS)

Some APIs ask the caller for a certificate as well (mutual TLS, mTLS). Client certificates are set per host, not per request: every request to that host presents it — on Send, in Run first, collection runs, Compare and performance tests — together with whatever Auth the request uses.

Open Manage certificates on the Settings tab, or Client certificates (mutual TLS) in the command palette. To add one:

  1. Host — api.example.com; *.example.com for every subdomain (one level); add a port, api.example.com:8443, to use it on that port only. When several match, the exact host wins over a wildcard.
  2. The format: Certificate + key (PEM, CRT) — choose both files — or PFX / P12 — one file.
  3. Passphrase, if the key or the PFX file has one.
  4. Add certificate. The app checks it first: The passphrase is wrong or The private key doesn't belong to this certificate means nothing was saved.

The list shows each certificate's host, name (CN), format, and how long it is valid — an expired one is marked in red. The bin removes it. The Settings tab says the one for \.example.com* when a request uses one, none for this host, or only for https addresses (plain http never sends a certificate).

The public certificate is kept in certificates.json in your data folder; the private key, a PFX file and the passphrase are encrypted with your other secrets and never exported. An OAuth token URL that wants a certificate gets it too.

Trusted certificate authorities. The desktop app trusts the certificates your computer trusts — so servers signed by your company's CA, and a company proxy that inspects https traffic, work without any setting. For a CA your computer doesn't know, open Manage certificates and Add a CA certificate (.pem or .crt; a file with several is fine). The list shows each CA's name and how long it is valid; the bin removes it. Only CA certificates are accepted — not a server's own certificate. Requests then check servers against these CAs instead of skipping the check. In performance tests: on Linux, k6 is given the same CAs. On Windows and macOS k6 can't load extra CAs, so when a server needs one of yours, the app checks its certificate with your CA once before the test and k6 skips its own check during the test.

Reading the answer

While it's sending, the answer area shows each step as it happens, with its time: Prepared (folders, connection, variables), Run first, the OAuth token (the saved one, or a new one from the sign-in server), the pre-request script, Waiting for the server, Downloading the answer. Cancel stops the request.

Answers are shown whole — up to 20 MB (beyond that, the first 20 MB). One over 2 MB waits behind a panel, because showing that much text takes a moment: Show it, As plain text, or Save to file — or Always show big answers. Checks and Save values always use the whole answer.

The Response panel shows:

  • the status (200 OK, 404 Not Found…), the time, the size, and the content type;
  • Body — see below;
  • Headers — response headers. Copy all copies them as Name: value lines. Sign-in headers such as Authorization and Set-Cookie are hidden as [redacted];
  • Cookies — when the answer set any: each cookie with its domain, path, expiry and flags (HttpOnly, Secure, SameSite), including cookies set by redirects on the way. Values stay hidden until Show values;
  • Checks — each rule with ✓ or ✕, and why a failed one failed;
  • Request sent — exactly what went out, and the same request as code (below).

The Body tab has these views:

  • Pretty formats JSON with colours.
  • Raw shows the answer exactly as it came.
  • Preview — for HTML answers, the page as a browser would show it. It is sandboxed: scripts on the page do not run. For images (PNG, JPEG, GIF, WebP, SVG and others, up to 5 MB) Preview shows the picture, and the download button saves the image file.

The buttons on the right search the body (Ctrl+F; Enter and Shift+Enter move between matches), turn line wrapping on or off, copy the body, and download it as a file.

The app shows the first 64 KB of a large body; it says First 64 KB shown, and the size ends with +. Checks and saved values still use the whole answer.

Earlier answers: look back, and see what changed

A saved request keeps its last 20 answers. Once it has more than one, Earlier · N appears at the top of the response:

  • Pick an answer to open it — the status, headers, body and checks as they were then. A bar says which answer you are looking at; Back to the latest returns.
  • Compare with the latest shows what changed: the status and time, the fields that changed in a JSON answer ($.status: "paid" → "shipped", fields added or removed), and the body line by line, with removed lines in red and added ones in green.
  • Forget these answers deletes them.

Each answer is kept whole, with its size in the list; the list shows how much they take in all. Forget these answers clears one request's; Settings → Data and storage → Kept answers shows the total for the project and clears all of them. Hover over a saved request to see how much its answers take.

It's how you notice that an API quietly changed what it returns — a field renamed, a value that's suddenly empty — or check what a fix changed.

The answers are kept on this computer, in the responses folder of your data folder, apart from the requests. Values that look like secrets — fields named like token, password, key, secret, session — are replaced by <hidden> before an answer is written, so a sign-in's answer doesn't leave a token on the disk. (Comparing such an answer shows those fields as changed.) Requests you haven't saved, WebSockets and event streams aren't kept.

Request sent: what actually went out

The request you see in the editor isn't always what the server gets: variables are filled in, folders add their auth and headers, OAuth gets a token, OAuth 1.0 and AWS sign the request, the cookie jar adds cookies. Request sent shows the real thing — the final address, every header in order (also the ones the HTTP client adds, like host and content-length), the body, and any redirects that were followed. A line says how auth got there, for example OAuth 2.0 — the app got the token and sent it as a Bearer token.

Secrets — Authorization, cookies, API keys, a key in the address — show as <hidden> until Show secrets. When a request fails without an answer, What was sent under the error shows the same.

Code writes the same request for curl, PowerShell, JavaScript (fetch), Python (requests), C# (HttpClient), Java (HttpClient), Go (net/http), or as a k6 performance test script to run with k6 yourself. Pick one and Copy; the app remembers your choice. The code has <hidden> in place of secrets unless you choose Show secrets first. Signed values (OAuth 1.0, AWS, Digest, NTLM) are good for that one request only, and a token works until it expires. On Windows, curl.exe can garble non-English letters typed in the command line — use the PowerShell code there.

If the request used Run first, a line under the status says what ran first and which values it found. When the request fails without an answer — for example Connection refused or Timed out — the panel says what that usually means and what to try.

Saving requests and collections

Press Ctrl+S (or Save, beside Run performance test) to keep a request. Give it a Name and, optionally, a Collection — a folder that groups related requests, like Orders API. Pick an existing one from the list or type a new name. Use / for a folder inside another: Orders API/Admin. Folders nest up to 6 levels.

Once a request is saved, its name is on its tab. When you change it, a dot appears on the tab and on Save: press Save (Ctrl+S) to update it, or the arrow next to it → Save as a new request… to keep the original and save a copy.

Saved requests are plain files on your computer. Secrets in them (tokens, passwords, API keys) are kept encrypted, never in the file — see Privacy and your data.

The Saved requests panel

Saved requests are listed on the left, in their folders. Click one to open it. Search requests finds them by name, folder, URL, or method.

ActionHow
Start a blank requestNew request (the page icon at the top of the panel)
Make a folderNew folder (the folder icon at the top), or ⋯ → New folder inside on a folder. Type Orders/Admin to make both at once.
New request in a folderThe folder's ⋯ → New request here: it's made in that folder and opened, with its name ready to type.
Folder settings, rename, deleteHover over a folder and press ⋯ (or right-click it): Folder settings — auth, headers, variables, New folder inside, Rename or move (type Archive/Old to move it into Archive), Delete folder (only when no requests are left in it)
Import requestsThe arrow icon at the top of the panel. See Importing.
Fold or unfold a collectionClick its name
Run every request in a folderHover over the folder and press ▶ — its subfolders are included. See Run a collection.
Open, rename, move, duplicate, see its versions, exportHover over a request and press ⋯ (or right-click it): Open, Rename (F2), Duplicate (Ctrl+D), Move to…, Version history, Export…, Move to Trash (Del). The keys work on the request that has focus.
Move by draggingDrag a request onto a folder — or onto empty space for the top level
Work on several at onceCtrl+click (⌘ on a Mac) to pick requests one by one, Shift+click for a range. A bar above the list then moves, exports or trashes them all; drag any of them to move them together.
Delete a request⋯ → Move to Trash. It can be restored for 30 days — see Version history and Trash. Performance test history is not affected.
Hide the panelCtrl+B, or the folder button at the left of the tabs — both bring it back, too.

Opening a request opens it in a tab of its own, so nothing you haven't saved is thrown away; closing a tab with unsaved changes asks first.

Version history and Trash

Every save keeps the version it replaces — the last 50 of each request. To see them, open the request and choose Save ▾ → Version history…, or ⋯ → Version history in the panel. Pick a version on the left to see what changed between it and now, part by part (Address, Headers, Body, Checks…). Restore this version makes it the current one; what was saved before is kept as a version too, so a restore can always be undone. Versions don't hold secret values — a restored version keeps the secrets the request has now.

Deleting a request moves it to Trash (at the bottom of the sidebar, or Trash in the command palette). There, Restore puts it back in its folder — with its secrets and versions — and ✕ deletes it for good. Requests in Trash are deleted for good after 30 days, or when you press Empty Trash.

Both live in your data folder, next to your requests (versions/ and trash/).

Folders: sign in once

A folder can pass settings down to every request inside it, and inside its subfolders. Open them with ⋯ → Folder settings on the folder. A 🔑 next to a folder's name means it sets auth.

TabWhat the requests inside get
AuthThe folder's sign-in. Requests set to Auth → From folder use it — that's the default for new requests, so you type a token once instead of in every request. From parent passes on the auth of the folder above; None stops it.
HeadersSent with every request inside. A request's own header with the same name — or an inner folder's — replaces it.
VariablesDefaults for {{name}}. The chosen environment wins when it has the same name, so a folder can hold basePath = /v2 while the environment picks the server. See Which value wins.
ScriptsA pre-request and a tests script that run for every request inside, before the request's own — see Scripts on folders.
API descriptionAn OpenAPI file the answers inside are checked against — see Contract tests.
DocsWhat the folder is, in Markdown: the top of its part in the API docs.

On a request, Auth → From folder says where its auth comes from (Uses the Bearer token set on the folder Orders API), and the Headers tab lists the headers it gets from its folders. A request that sets its own auth type keeps it.

Folder secrets — a token, a password, an OAuth client secret, a secret variable — are kept encrypted on this computer, like a request's, never in the folder's file (_folder.json inside the folder). Folder settings apply everywhere a request is sent: Send, performance tests, Compare, Run first, collection runs, and the command line.

OAuth 2.0

Choose Auth → OAuth 2.0 on a request — or, better, on a folder, so every request inside signs in once. The app gets the token from your sign-in server, sends it as Authorization: Bearer …, keeps it encrypted on this computer until it runs out, and gets a new one by itself.

Grant typeUse it forYou fill in
Client credentialsService to service — the app signs in as itself. The best choice for performance tests.Token URL, Client ID, Client secret, Scope
PasswordSigning in as a user with a username and password (older APIs, test accounts)The same, plus Username and Password
Authorization codeSigning in as a user in the browser, onceAuthorization URL, Token URL, Client ID (and Client secret if it has one), Scope, Redirect URL, PKCE (on by default)

Two more grants, and one more way for the client to prove itself (choose them under Grant type and More):

ChoiceForYou fill in
JWT bearer grantSalesforce, Google service accounts — no browser, no user passwordPrivate key (PEM), Issuer (defaults to the client ID), Subject (the user, if the API wants one), Audience (defaults to the token URL), and Extra claims as JSON (Google: { "scope": "…" })
SAML bearer grantSAP SuccessFactorsEither SuccessFactors builds it — the Assertion URL (https://<your API server>/oauth/idp), User ID, Company ID and the Private key of your OAuth client — or I have an assertion and paste it (base64). The builds it way sends your private key to SuccessFactors, as SAP documents; for production, prefer an assertion from your identity provider.
More → Signed with a private key (client assertion, private_key_jwt)Azure AD with a certificate, Okta, KeycloakPrivate key, and the Certificate if Azure AD should find the key by its thumbprint (x5t); no client secret

The private key is kept encrypted. Signed assertions last five minutes; in performance tests the app signs the ones each simulated user needs to renew its token ahead of time, so the key never goes to the load generator. SuccessFactors builds each SAML assertion on its side, so its tokens (valid about a day) are not renewed during a performance test.

For Authorization code, add the Redirect URL — http://127.0.0.1:53682/callback unless you change it — to your OAuth app exactly as shown. It must be on this computer. Then press Sign in in the browser: your browser opens the sign-in page, and after you sign in the app catches the answer and keeps the token and its refresh token. Later requests, performance tests and runs refresh it without asking. If the refresh stops working, press Sign in again.

The panel under the settings shows the token: Token ready · expires in 54 min · orders:read. Get new token fetches one now (client credentials and password); the bin forgets it. Errors from the server are explained — for example invalid_client — check the client ID and secret, and whether they go in a header or the body.

Under More:

  • Send the client ID and secret — In a Basic auth header (the default) or In the request body. Servers differ; if you get invalid_client, try the other.
  • Extra fields — added to the token request and the sign-in page, such as audience or resource.

Every field takes {{variables}}, so the client secret can come from an environment or, in CI, from --var clientSecret=…. Changing the client, user, secret or scope gets a new token.

In performance tests the token is fetched once before the test starts. If the test runs longer than the token lasts, each simulated user gets a new one shortly before it runs out — client credentials and password ask the server again; authorization code uses the refresh token. Those token requests are counted in the test's numbers (one per simulated user per token lifetime).

On the command line, OAuth works the same way. Authorization code needs the browser once: sign in in the app (or npx apitestcenter ui) with the same data folder, and runs on that computer reuse and refresh the token. In CI, use client credentials.

Importing requests

From Postman, Insomnia, Bruno, .http files, Hurl, a browser recording, OpenAPI, or a SOAP service's WSDL.

Click Import (the arrow icon in the Saved requests panel), or choose Import requests in the command palette. Then Choose a file — or several at once — or drop them on the dialog:

  • Postman collections (v2.0 and v2.1) and Postman environments;
  • Insomnia exports — the Insomnia v4 JSON and the newer v5 YAML: folders (with their auth and environment, as folder settings), requests, base and sub-environments, and every auth type the app supports. Insomnia's {{ _.name }} variables become {{name}}; template tags ({% … %}) are kept as text and listed, to replace by hand;
  • a browser recording (HAR) — in Chrome or Edge, open DevTools → Network, use the web app, then right-click → Save all as HAR. The app keeps the API calls — one folder per site — and leaves out page files (images, scripts, styles, fonts), CORS preflights, repeats and the headers browsers add on their own. An Authorization header becomes the request's auth. Cookies are left out: send the login request first and the cookie jar keeps its session. Record → import → performance test is a quick way to test what a page really calls;
  • OpenAPI 3 and Swagger 2 files, as JSON or YAML (.json, .yaml, .yml);
  • a SOAP service's WSDL (.wsdl or .xml; WSDL 1.1, SOAP 1.1 or 1.2), such as SAP's (ECC, S/4HANA, PI/PO), NetSuite SuiteTalk's or SuccessFactors' SFAPI. Each operation becomes a request: a POST to the service's address (kept as {{serviceUrl}} in a new environment), the SOAPAction, and a sample envelope built from the WSDL's schema, with ? where a text value goes and comments for optional, repeating and either-or elements. Each gets two checks: no SOAP Fault, and the operation's response is there. A WSDL doesn't say how to sign in, so set Auth on the collection's folder (Basic for most SAP services). Many services publish their WSDL at their address followed by ?wsdl: choose Or from a web address, type that address, and a user name and password if it needs a sign-in (SAP usually does; they're used once and not kept). The app fetches it through your proxy and certificates, as Send does. The practice SOAP service has one at {{practiceApi}}/soap/employees?wsdl, and {{practiceApi}} works in the address;
  • Bruno — a collection exported as JSON (Collection settings → Export → Bruno Collection), with its folders and environments; or its .bru files: open the collection's folder in Choose a file, select them all, and they come in together. Bruno's assertions (res.status: eq 200, res.body.id: isDefined…) become checks. Bruno's scripts and tests use its own bru.* and res.* objects, so they aren't imported — the import lists the requests that had them;
  • .http and .rest files — from the VS Code REST Client and the JetBrains HTTP Client: every request between ### lines, its name (### List orders, or # @name), headers and body. @name = value lines at the top become an environment. JetBrains response handlers (> {% … %}) aren't imported;
  • Hurl files (.hurl): requests with their [QueryStringParams], [FormParams], [BasicAuth] and body; the expected HTTP 200 and the [Asserts] become checks, and [Captures] become saved values for the requests after it.

All of these use {{variables}} the way the app does, so they work as they are.

Imported requests run in the order they came — a sign-in before what uses it — in collection runs, as in Postman. Requests already in that collection run first; change the order on the Run collection page.

APITestCenter collection files

An APITestCenter collection file (.json) holds requests, their folders and an environment; a request in it can sign in first with another request of the same file. Import one like any other file. Its environment is picked for you after the import.

Files can be up to 20 MB. No file? Click Or paste it instead, paste the JSON or YAML, and press Read it.

Before anything is saved, the app lists what it found — requests, folders, environments — and anything it could not bring across (for example, Insomnia template tags). Auth carries over for Bearer, Basic, API key, Digest, NTLM, OAuth 1.0, AWS Signature and JWT (OAuth 2.0 settings must be entered again), and GraphQL bodies stay GraphQL. Forms with files come across with their fields; the files themselves aren't in an export, so choose each one again on the Body tab (the import says which). A pasted curl -F 'photo=@me.png' works the same way. A Postman request's saved example becomes its Example (the first successful one). Postman folders stay folders inside the collection, and the auth and variables set on a Postman collection or folder become that folder's settings, which its requests inherit — as in Postman. Variables in requests stay as {{variables}}.

Put the requests in collection names the top folder they go into. It starts as the file's title; change it if you like (up to 60 characters). Folders inside it keep their names. If that collection already has requests, they are kept and the new ones are added.

Your current requests are not changed. Press Import to save — the button says how many requests and environments it will add.

From an OpenAPI or Swagger file, each request also gets checks: the documented success status (200, 201…), and — when the file says what that answer looks like — a JSON schema check made from it. So every Send and every performance test also tells you whether the API still matches its documentation. Where the API really differs from the file, change or remove that check on the Checks tab.

Something unclear or missing? Write to support@apitestcenter.com — the guide improves with every question.