Importing Postman Collections into Xolo

Xolo lets you migrate an existing Postman workflow without starting from scratch. When you import a Postman Collection v2.1 JSON file, Xolo reconstructs the entire folder hierarchy, recreates every saved request with its method, URL, headers, query parameters, and body, and automatically converts a supported subset of Postman test scripts into native Xolo assertion rules — so your validation logic travels with the collection.

Supported Format

Xolo reads Postman Collection v2 JSON (exported from Postman as “Collection v2.1”). The root JSON object must contain:

info.name — used as the collection name in Xolo (falls back to "Imported Postman Collection" if absent)
item — the top-level array of requests and folders

{
  "info": {
    "_postman_id": "abc-123",
    "name": "My API",
    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
  },
  "item": [...]
}

The ImportManager.detectFormat() method identifies a Postman file automatically by checking for info._postman_id or a top-level item key, so you can also leave the format picker on Auto-detect.

Import Steps

Export from Postman

In Postman, open the collection, click the ⋯ menu, choose Export, and select Collection v2.1 (recommended). Save the .json file to your device.

Open the Import dialog in Xolo

Tap the sidebar menu → Import → Collection. The ImportCollectionDialog opens with source tabs for URL and File, and a format dropdown defaulting to Auto-detect.

Select the JSON file

Switch the source toggle to File and tap Select file. The system file picker opens filtered to .json files. Choose the Postman export you saved in step 1.

Choose a destination

Leave the destination blank to import into the root workspace, or pass targetCollectionId to nest the collection inside an existing parent. The dialog forwards this value directly to PostmanService.importFromJson().

Confirm the import

Tap Import Now. Xolo parses the file, creates the folder hierarchy and requests, and shows a success snackbar. The new collection appears immediately in the sidebar.

What Gets Imported

PostmanService._parseItems() walks the item array recursively. Each element is treated as either a folder (has a nested item array) or a request (has a request object):

Field	Postman source	Notes
Collection name	`info.name`	Top-level root collection
Folder name	`item[].name` with `item[].item`	Nested sub-collections
Request name	`item[].name`
Method	`request.method`	Upper-cased; defaults to `GET`
URL	`request.url.raw` or reconstructed from `host`+`path`
Query parameters	`request.url.query[]`	Imported as active key-value pairs
Headers	`request.header[]`	Imported as active key-value pairs
Body (raw)	`request.body.mode == "raw"`	Imported verbatim
Body (urlencoded)	`request.body.mode == "urlencoded"`	Converted to pretty-printed JSON map
Description	`item[].description`	Stored on collection folders

If a collection or request with the same name already exists under the same parent, Xolo upserts it — updating the existing record rather than creating a duplicate.

Assertion Mapping

PostmanAssertionMapper.fromPostmanEvents() scans every event block where listen == "test" and converts the script lines it recognises into AssertionRuleEntity values stored in the request’s assertionsJson column.

Postman test script	Xolo assertion rule
`pm.response.to.have.status(200)`	`statusCode equals 200`
`pm.expect(json.token).to.exist`	`jsonPathExists $.token`
Other `pm.*` tests	Skipped (unmapped)

The mapper handles both the pm.expect(json.<field>).to.exist and pm.expect(<obj>.<field>).to.exist regex variants. Mapped rules are encoded as JSON and saved to the request automatically during import.

// PostmanAssertionMapper.fromPostmanEvents() — called inside PostmanService._parseRequest()
final assertionRules = PostmanAssertionMapper.fromPostmanEvents(
  item['event'] as List<dynamic>?,
);
final assertionsJson = PostmanAssertionMapper.encodeRules(assertionRules);

Postman test scripts beyond the mapped subset — including complex JavaScript assertions, pm.test() callbacks with custom logic, response schema validation, and cookie/header assertions — are not imported. A badge on the collection shows the count of lines that were skipped. Review unmapped tests and recreate them manually as Xolo assertion rules.

`PostmanService.importFromJson()` Reference

Future<void> importFromJson(
  Map<String, dynamic> json,  // Parsed Postman v2 JSON object
  int? parentId,              // ID of the parent collection, or null for root
  AppDatabase db, {
  int? targetCollectionId,    // Import directly into this existing collection ID
}) async

Parameter	Type	Description
`json`	`Map<String, dynamic>`	The full parsed Postman collection object
`parentId`	`int?`	Parent collection ID. Pass `null` to create at the workspace root
`db`	`AppDatabase`	The active Drift database instance
`targetCollectionId`	`int?` (named, optional)	Skip root creation and import items directly into this collection

When targetCollectionId is provided, the info.name from the Postman file is ignored for the root-level collection — all items are imported as children of the specified collection.

cURL Import

For one-off requests, Xolo also supports importing a single curl command without creating a new collection.

Open the cURL dialog

Tap Import → cURL from the top toolbar (or within any open request tab). The ImportCurlDialog opens with a monospace text area.

Paste the curl command

Paste a complete curl command. The command must start with curl; otherwise the parser returns null and displays a validation error.

Confirm

Tap Import. CurlParser.parse() extracts the method (-X/--request), URL, headers (-H/--header), and body (-d/--data/--data-raw), then applies them directly to the currently active request tab.

// CurlParser.parse() return type
class ParsedCurl {
  final String method;           // e.g. "POST"
  final String url;              // e.g. "https://api.example.com/users"
  final Map<String, String> headers;
  final String? body;
}

If the curl command contains a body (-d) but no explicit -X flag, CurlParser automatically infers POST as the method.

Postman environment variables (e.g. {{base_url}}, {{token}}) are not imported — Postman environment JSON files are a separate export artifact and are not part of the collection file. After import, recreate your variables in Xolo’s Environments screen and reference them with the same {{variable}} syntax.

Get Started

Core Features

Authentication

Scripting & Automation

Import & Sync

Importing Postman Collections into Xolo

Supported Format

Import Steps

What Gets Imported

Assertion Mapping

`PostmanService.importFromJson()` Reference

cURL Import

​Supported Format

​Import Steps

​What Gets Imported

​Assertion Mapping

​PostmanService.importFromJson() Reference

​cURL Import

Supported Format

Import Steps

What Gets Imported

Assertion Mapping

`PostmanService.importFromJson()` Reference

cURL Import