Postman Collection v2.1 / v2.0¶
Parses exported Postman Collection JSON (schema v2.1.0 and v2.0.0) into the Vayu draft model. Both versions share the same parse implementation; the only differences are detection and the shape of the url/auth objects (handled transparently by the shared helpers).
- Source:
engine/src/core/import_document.cpp - Exports:
The parse moved engine-side (issue #877). Every rule on this page is the same rule it always was - the corpus in
engine/tests/fixtures/import-conformance.jsonwas recorded from the parser this replaced and is asserted against on every build - it is simply read byengine/src/core/import_document.cppnow, behindPOST /import/parse, rather than in the renderer. Module names in C++ style below name that file's functions; the app holds no parser.
| Class | formatName |
formatKey |
|---|---|---|
PostmanV21Parser |
Postman Collection v2.1 |
postman-v21 |
PostmanV20Parser |
Postman Collection v2.0 |
postman-v20 |
Both implement ImportParser (detect + parse) from ./types.
Detection¶
The factory (core::parse_import) parses the raw string once (JSON, then YAML fallback) and runs each parser's detect(parsed, raw) in registration order until one returns true.
| Class | detect() logic |
|---|---|
PostmanV21Parser |
parsed.info.schema is a string containing "v2.1.0". |
PostmanV20Parser |
parsed.info.schema is a string containing "v2.0.0"; or parsed.info is present, parsed.item is an array, and schema == null (no schema field at all → treated as v2.0). |
The match is a substring check (schema.includes(...)), so the full schema URL (e.g. https://schema.getpostman.com/json/collection/v2.1.0/collection.json) is accepted.
Why v2.1 is tried first: the factory's PARSERS array lists PostmanV21Parser before PostmanV20Parser. v2.1 has the stricter test (exact v2.1.0 substring), and v2.0's fallback branch is permissive (it claims any info + item[] document with no schema). Ordering v2.1 first ensures a true v2.1 file is never swallowed by v2.0's loose fallback.
Parse flow¶
parse_postman(parsed, options, format) serves both versions:
- Creates one
PostmanCounts(the options, the request and folder counts, a counter per skipped kind, the client-certificate candidates, and the request names each counter grew on) threaded through the whole walk. - Calls
pm_folder(parsed, {}, counts)on the top-level collection object itself - the root collection is just a folder whoseinfocarries the collection name/description. - Builds
meta, adding aSkippedItemfor each counter that is greater than zero.
Tree walk - pm_folder¶
pm_folder(node, inherited, counts) walks node.item[], passing down resolved: inherited (the enclosing nodes' protocolProfileBehavior, merged) overlaid with the node's own - see Redirect settings. For each child:
- Folder (
child.itemis an array) →counts.folders += 1, recurse viapm_folder(child, resolved, counts), push intochildren. - Request (
child.requestis truthy) →pm_request_named(child, resolved, counts), push intorequests. - Not an object at all (
null, a string, a number) → skipped, counting towardmalformed_item. Hand-edited or script-filtered JSON can contain these, and the v2.0 detector's permissive fallback accepts such a file; such an entry used to fail the whole import with an error naming neither the format nor an item.event[]entries are filtered the same way (pm_events). - Anything else (an object with no
item[]and norequest) is silently ignored.
Folder vs request discrimination is purely structural: presence of an item array makes a node a folder, otherwise presence of a request makes it a request. Nesting is bounded by the engine's reader, not by the walk: read_document refuses a document nested past MAX_READ_DEPTH (100 levels, about 50 folders) before pm_folder runs, so a hostile file fails with a "nests deeper" error rather than overflowing the stack.
Document order is kept (issue #2535). Postman runs a folder's items in the order the file lists them and descends into a sub-folder where it sits, so a "Log in" request at the top of a collection runs before the folders after it. Each folder and request draft records its position among the items kept from its parent's item[] as order, and the apply numbers a parent's sub-folders and requests in that one sequence: the sidebar lists them, a recursive run visits them and an export writes them in the file's order. Postman's own collection-v2.json example, two requests then a folder at the root and three requests then a folder inside it, imports exactly so.
The returned CollectionDraft carries name, description, variables, auth, its script elements, and its children/requests. The root and every folder are built by the same function - the root is simply the outermost pm_folder result and becomes collections[0] (the only root; parentId = null, and no order, because it joins the roots already stored).
Request build - pm_request¶
pm_request(item, inherited, counts) reads item.request, derives url/params via pm_url, maps auth via map_postman_auth, and increments counts.requests. Whether its auth is data-only is not decided here: it depends on the folders above the request, so parse_postman reads it off the finished tree (see nonExecutableAuth counting). Scripts come from item.event[] (prerequest, test); redirect settings come from item.protocolProfileBehavior resolved through its folders (see Redirect settings). pm_request_named wraps it to record which request each per-request counter grew on.
Field mapping¶
Collection (root)¶
The root is produced by pm_folder(parsed, {}, counts); parsed is the whole collection object.
| Postman | Vayu CollectionDraft |
Notes |
|---|---|---|
info.name → name (fallback name → "Imported Collection") |
name |
info.name ?? name ?? "Imported Collection" |
info.description (fallback description) |
description |
string used directly; if object, .content is used; else "" |
variable[] |
variables |
via to_var_record |
auth |
auth |
via collectionAuth (see Auth) |
event[] |
elements |
via set_event_elements - see Scripts; none when importScripts is false |
nested item[] (folders) |
children |
recursion |
item[] (requests) |
requests |
|
an item's position in its parent's item[] |
order on each folder and request draft |
one count across both kinds, malformed entries skipped - see Tree walk |
Collection (folder)¶
Same pm_folder mapping. A folder node has name/description/variable/auth/event at the top level (no info wrapper), but the code reads node.info?.name ?? node.name and node.info?.description ?? node.description, so both shapes work. Each nested folder increments counts.folders.
Request¶
Postman (item / item.request) |
Vayu RequestDraft |
Notes |
|---|---|---|
item.name |
name |
fallback "Untitled" |
request.description, else item.description |
description |
string used directly; if object, .content; else "". The schema allows either place and generated collections use the item's; the export writes it on the request, where Postman's own export puts it |
request.method |
method |
toMethod: upper-cased; if not one of GET/POST/PUT/PATCH/DELETE/HEAD/OPTIONS → GET, counted as unsupported_method (a custom verb such as PROPFIND or PURGE) |
request.url |
url, params |
via pmUrl (see URL handling) |
request.header[] |
headers |
via map_key_values; a row's type other than "text" (recent Postman writes "default") is kept on the row for the export to write back. The v2.1 schema also allows header to be a string (the text of the headers pane); it is read as Postman's Header.parse reads it, line by line (map_header_rows): name: value with the value trimmed, so a Hawk Authorization keeps its colons; a line with no colon, with leading whitespace, or with a space before the colon (Key : v) names nothing and is skipped; a line continued by a following space- or tab-led one (header folding) is joined with one space; CRLF and LF both end a line. One difference: the name ends at the first colon, where Postman's \S+ may run to the last colon of an unspaced line (Location:http://x). A saved response's header takes the same string form |
request.body |
body |
via pmBody (see Body mapping) |
request.auth |
auth |
via map_postman_auth; inherit allowed for requests |
item.event[] |
elements |
via set_event_elements - see Scripts; none when importScripts is false |
item.protocolProfileBehavior.followRedirects (and the five like it: read from the object resolved through the folders, see Redirect settings) |
followRedirects |
only when it is a boolean; otherwise absent (engine default true) |
item.protocolProfileBehavior.maxRedirects |
maxRedirects |
only when it is a finite number; otherwise absent (engine default 10) |
item.protocolProfileBehavior.strictSSL |
verifySSL |
only when it is a boolean; otherwise absent (engine default true) |
item.protocolProfileBehavior.disableCookies |
disableCookies |
only when it is a boolean; otherwise absent (engine default false) - issue #1765 |
item.protocolProfileBehavior.disableUrlEncoding |
disableUrlEncoding |
only when it is a boolean; otherwise absent (engine default false) |
item.protocolProfileBehavior.disabledSystemHeaders |
disabledSystemHeaders |
the names set to true, lowercased, in source order, when it is an object |
item.protocolProfileBehavior |
postmanProtocolBehavior |
the whole object as JSON text in source member order, {} included, for the export to write back |
item.response[] |
examples |
via pmExamples (see Saved responses); absent when the item saved none |
request.certificate |
clientCertificates[] (top-level, not a request field) |
resolved into a client_certificates registry candidate keyed on the request's own host (issue #1656) - Vayu's client certificates belong to a host, not a request. The preview lists each candidate (host, port, certificate path, key path; never the passphrase) in a Client certificates section and registers it only when the user ticks it: unticked by default, nothing registered until then, because the row is host-wide and outlives the import (issue #2363). The ticked ones are applied best-effort by POST /import/apply after the rest of the tree commits. A candidate is resolved only when it would pass the same check POST /client-certificates runs: a readable PEM pair or PKCS#12 file, a literal (not {{var}}) host, and no earlier request in this import already claiming a different certificate for that (host, port). Anything else counts as certificate instead, as does a resolved candidate left unticked (the preview adds those to the engine's count) |
request.proxy |
- | not imported - Vayu has no per-request proxy override, and none is planned: TransportPolicy is workspace/run-scoped (engine/CLAUDE.md), so this stays a permanent tally rather than a mapping (issue #1656's own recorded decision); counted as proxy_config |
Scripts¶
set_event_elements turns every event[] entry into one element, in the
order the document lists them: prerequest becomes script.pre, test
becomes script.post, and the script is join_exec of its exec. Postman
runs every event of a listen in order, and Vayu runs every script element of
a phase in order, so a second test event is a second element (it used to be
dropped without a count) and a level that lists test before prerequest
exports back that way. An event marked disabled: true is one Postman's
runtime skips, so it imports as an element with enabled: false rather than
a script that runs. A blank script contributes nothing. A script that is
itself a string is the script's text, as in Postman's SDK (it used to import as
nothing).
Scripts that cannot be imported are counted, not dropped (issue #2541). An
enabled event whose script.src is set (Postman reads src as a URL to fetch
the script from and ignores exec beside it, so neither is imported) or whose
listen is not prerequest or test (Vayu has no phase for it) and carries
script text is counted under the script_unsupported kind in meta.skipped,
once per event. The request, folder or collection that declares it is named in
requests; a folder's requests come first, then the folder, then the
collection last, as with nonExecutableAuthRequests. A disabled event, a blank
unknown-listen script and every event of an import with importScripts off
count nothing. script.packages is not counted here: it is reported once, by
meta.unsupportedScriptApis, and that holds for an
event whose exec is blank too.
Scripts that use an API Vayu does not run. The scripts that will run are
also read for a fixed list of Postman script APIs Vayu has no implementation
of, and each request, folder or collection that uses any is named in
meta.unsupportedScriptApis. The list is a table in
engine/src/core/script_api_scan.cpp (API_RULES): require(...) of a module
that is not on the require shelf
(crypto-js, uuid, lodash, moment, csv-parse/lib/sync, xml2js, chai, ajv and tv4, each matched
whole, the names the scan reads from the call's string
literal; a computed name such as require(name) is named) and pm.require, a non-empty
script.packages, the libraries Postman bundles that the shelf does not carry
(cheerio, Backbone), Buffer, the browser and Node globals the sandbox lacks
(fetch, XMLHttpRequest, URL, URLSearchParams, TextEncoder, TextDecoder,
structuredClone, localStorage, sessionStorage; one the script declares itself
is not named), the pm.* members that are undefined at run time (pm.test.skip,
pm.test.index, pm.execution.runRequest, pm.execution.location,
pm.response.dataURI, pm.response.jsonp, pm.response.headers.map,
pm.request.headers.map, pm.request.url.variables, and the
flat cookie writers pm.cookies.set, pm.cookies.unset and pm.cookies.clear, each
its own name; pm.cookies.jar() runs and is not named), pm.response.json(reviver)
(json() runs but ignores a reviver, so only a call that passes an argument is named;
the empty pm.response.json() is not), the console methods
console.debug, console.table, console.dir and console.time, and the one chai
family pm.expect still refuses,
chai-postman's .postmanRequest, .postmanResponse and .postmanRequestOrResponse
(named as one row). process, window, document and alert are deliberately not
scanned (common identifiers in a script's own code, so a notice would be wrong more often
than right), nor are the other console methods or a name read through an alias; a script
using one imports with no notice and throws when it runs
(the full account). Every other chai and chai-postman member runs, so none is named
(engine/tests/fixtures/chai-conformance.json is the authority, and
script_api_scan_test.cpp holds the table to it). require('crypto-js'), the
CryptoJS members the shim defines (#2578), require('uuid') (#2650) and lodash,
as _ or require('lodash') (#2651), require('moment') (#2652) and
require('csv-parse/lib/sync') (#2653), xml2js, as xml2Json or
require('xml2js') (#2654), and require('chai') (#2655) run, so they are not named
(require('csv-parse') and every other path under it still are); the rest of
crypto-js is, under the one name CryptoJS (CryptoJS.AES, PBKDF2, SHA3,
RIPEMD160, algo.*, enc.Base64url, lib.WordArray.random, a computed
CryptoJS[name], ...), whether it is read off CryptoJS, off a name bound to it
(const C = CryptoJS; C.AES), off require('crypto-js') or through a
destructure of either (const { AES } = CryptoJS). The scan follows a name from
its const, let or var declaration on, whole-script and without scopes; a
reassignment, a second declarator of a statement and a name passed through a
parameter are not followed. The supported members are one list,
CRYPTO_JS_MEMBERS in engine/include/vayu/runtime/shelf_modules.hpp, that
script_completions_test.cpp holds to what the runtime defines and the editor
offers. Postman's pre-pm.* globals
(tests[...], responseBody, environment, ...) and the postman.* methods
run (see Postman's legacy globals),
and pm.visualizer is accepted with a console warning (see
Visualizer), so none is
named. A row is retired in the commit that makes Vayu run the API.
The scan reads tokens, not text: comments, string and template-literal text and
regular-expression bodies are blanked first, so a name that only appears in a
comment or a string is not named, while the expressions inside a template's
${ } still are. A property (x.cheerio) is not the global of that name,
and a script that declares the name itself (const cheerio = ..., a parameter
named cheerio) is not reading the global. It is a notice, so it errs toward
naming too much and never toward missing a listed name. A disabled event runs nothing
and names nothing; with importScripts off nothing is read. The scripts are
imported either way: this never blocks or alters the import. The import
preview shows it as one amber line naming the requests and the APIs (Sign in:
script uses APIs Vayu does not run yet (require(), cheerio)), and the
import-scripts toggle is untouched.
Saved responses¶
Postman stores a request's recorded responses in item.response[]. They were read by nothing until the engine had a table for them (issue #481), so importing a collection whose value was its documented responses produced a collection with none - and the loss was not even counted.
pmExamples(item, ctx) maps each entry to an ExampleDraft:
Postman (item.response[] entry) |
Vayu ExampleDraft |
Notes |
|---|---|---|
name |
name |
fallback "Example" |
code |
status |
a numeric code must be a whole number from 200 to 599 (404.0 and 4.04e2 both import as the integer 404); anything else (a 1xx interim response, 0, 600, a fraction) is not a status a mock can serve - POST /import/apply refuses one outside the range and ignores a fraction, storing the default 200 - so that saved response is left out and counted as malformed_item while the request still imports (issue #3424). A code that is not a number, or is absent, is 200, which is what Postman shows for a saved response with no code |
header[] |
headers |
via map_key_values - source order and duplicates (Set-Cookie) preserved |
body |
body |
stored verbatim |
header[] Content-Type |
contentType |
"" when the recorded response carried none |
| the whole entry | postmanResponse |
JSON text, source member order, name and body as null placeholders; left out when over 1 MiB |
_postman_previewlanguage is deliberately not read into contentType: it is an editor mode ("json", "html"), not a media type, and storing it would put a value in that field which is not one.
postmanResponse keeps what no example field models - the request the response was recorded against (originalRequest, which usually differs per example: its own query values, headers, body and path variables), the status text as recorded, _postman_previewlanguage / _postman_previewtype, cookie[], responseTime, and the header rows as written (name fields, number values) - so an export writes them back. It is stored in request_examples.postman_response and read only by the Postman export; nothing is lost, so nothing is counted in meta.skipped. An entry whose text would pass the cap is imported without it and its export regenerates those members.
An entry that is not an object, whose numeric code is outside 200-599, or whose body is over 1 MiB (request_example::MAX_BODY_BYTES, measured in bytes) counts toward malformed_item, the same treatment pm_folder gives a malformed item. A request keeps its first 100 saved responses (request_example::MAX_PER_REQUEST) and each one past that is left out and counted the same way. POST /import/apply refuses both an oversize body and a request past the cap, so leaving them out here is what keeps one recorded response from failing the whole import (issue #3431). A request that saved no responses omits examples entirely rather than sending [] - the orchestrator forwards presence, and an empty array reads as "this request documents no responses".
meta.exampleCount totals what survived, counted off the drafts by count_examples (the same read-the-result approach unattached_file_parts uses), and the import preview shows it.
Redirect settings¶
Postman writes item-level protocolProfileBehavior exactly when the user overrides redirect, TLS, cookie, header or encoding handling for that request, so it is present precisely where it matters. pmRedirects(item) reads the fields Vayu stores per request and the orchestrator forwards them on POST /import/apply.
The three redirect and TLS fields are optional on the draft and omitted from the payload when the source did not state them - the engine then applies its own defaults (followRedirects: true, maxRedirects: 10, verifySSL: true). An absent field must not look like a stated true: the engine follows redirects and verifies certificates by default, so dropping a source false silently follows the 3xx the request exists to inspect, or trusts a host the export deliberately did not.
Values of the wrong type are ignored rather than coerced (a "false" string would read as the user's setting while being its opposite). A folder's or the collection's protocolProfileBehavior is read too (issue #2538). Postman resolves it the way postman-collection's getProtocolProfileBehaviorResolved does: the collection's object, each enclosing folder's and the request's own are merged in that order with the nearest winning, key by key and one level deep, whatever the value's type. Vayu stores these settings per request, so the import flattens that merge: pm_folder hands pm_request the object resolved so far (inherit_protocol_behavior), and the six settings Vayu applies (followRedirects, maxRedirects, strictSSL, disableCookies, disableUrlEncoding, disabledSystemHeaders) land on every request below the node that does not state its own. A request stating followRedirects: true under a folder that states false keeps true. There is no per-header merge: a request's own disabledSystemHeaders replaces the folder's wholesale, as in Postman (checked against Newman). The resolved values are what the request applies; postmanProtocolBehavior stays the request's own object alone, so a request with none states none. disableBodyPruning is resolved the same way but applies to nothing: it only decides whether a GET or HEAD body is reported (see below).
Since issue #1765 the three settings that change what Postman sends are
stored and applied per request, the same optional-on-the-draft way:
disableCookies (the cookie jar neither sends nor stores for the request),
disableUrlEncoding (path values and an api-key query sent as typed; the
query rows of such a request are joined into its URL unencoded too) and
disabledSystemHeaders (Postman's names set to a truthy value: user-agent,
accept, accept-encoding and content-type are refused on the wire,
connection, cache-control and postman-token are headers Vayu never sends
anyway). The whole object also rides along as postmanProtocolBehavior, JSON
text rather than an object so its member order survives the apply, and the
export writes it back.
disabledSystemHeaders is read the way Postman's runtime reads it, with one
deliberate difference. A value counts when it is truthy (true, 1,
"yes", an object), since the runtime tests disabledHeaders[key] in an
if; false, 0, "" and null do not. A key that is not a header name
("bad name") is left out of what the request applies rather than failing the
whole import, and still rides in the carried object. The difference: the
runtime looks each header up by its lowercase name without lowercasing the
object's keys, so an "Accept": true written by hand does nothing in Postman,
while Vayu lowercases the keys and honours it. Postman's own editor only ever
writes lowercase keys set to true, so the two agree on anything Postman
wrote.
A request is counted once as protocol_behavior only when its object names
something Vayu keeps for the export but does not apply: a key outside
followRedirects, maxRedirects, strictSSL, disableBodyPruning,
disableCookies, disableUrlEncoding and disabledSystemHeaders whose value
is not Postman's default (false, or an empty object or array) - a TLS option,
insecureHTTPParser - or host / content-length set in
disabledSystemHeaders, which Vayu cannot omit without breaking the request's
framing. disableBodyPruning is not counted as a setting: Vayu always sends a body.
It is read for a different count, body_on_get, below.
A body on a GET or HEAD (body_on_get, issue #2540).
Postman drops the body of a GET or HEAD request before it sends, unless the resolved
protocolProfileBehavior.disableBodyPruning is the boolean true. Vayu sends whatever the Body
tab holds, so such a request goes out with a body it never had in Postman. The import counts it
as body_on_get and names it under requests; the import itself is unchanged and the body
is kept. The preview line is amber: clear the body to match Postman, or leave it on purpose. A
request is counted when all of these hold, judged on the mapped request:
- its method is GET or HEAD (an unsupported verb that fell back to GET is counted as
unsupported_methodonly); - its body is not empty: a raw body with content, a GraphQL body, a binary file with a chosen
src(Postman's unselectedsrc: nullis not sent by Vayu either), or a urlencoded or form-data body with at least one enabled field. A body of modenone- including one switched off withdisabled: true- a file body with nosrc, and a body whose rows are all disabled send nothing, so they are not counted; disableBodyPruningis nottrueonce resolved. It is resolved through the collection and folders like the applied settings (inherit_protocol_behavior, nearest wins), so a request statingfalseunder a folder statingtrueis counted. Only the booleantrueopts out; a string or number is not Postman's opt-out either.
A GraphQL body on a GET is sent by Vayu as URL query parameters rather than a JSON body (see GraphQL); it is counted all the same, because Postman would send neither.
The same test runs on a folder's and on the collection's own object, with the result counted once per declaring node as protocol_behavior_folder (not once per request below it, and not again on those requests), with that folder's or collection's name under names. The preview says "folder or collection" for it where the protocol_behavior line says "request". The applied settings need no line: they arrive on the requests, where the Settings tab shows them.
URL handling¶
pmUrl(url) handles both shapes:
- String url (v2.0, sometimes v2.1): the text is cut at its first
#before anything else, as Postman'sUrl.parsecuts it, so a fragment never lands in a query value (?a=b&abcd#{{search}}is the querya=b&abcdand the hash{{search}}); the hash stays on the base URL and the join puts the query before it. With no?, the rest is the base URL (normalize_template_varsapplied),params = []. If there is a?, the substring before?is the base and the query string goes throughqueryEntries: split on&and each pair on its first=, never decoded (Postman'sQueryParam.parsedoes not decode either), withvaluerun throughnormalize_template_vars; a missing=yields an empty value markedvalueless: true, which rejoins as a barekeywherekey=rejoins askey=. All extracted params areenabled: true. - Object url (v2.1):
url.rawis cut at its first#and then at the first?to get the base (the fragment kept on it, as above;url.hashis appended as#<hash>only whenrawhas no#of its own) (normalize_template_varsapplied); query parameters come fromurl.query[]viamap_key_values(so disabled query params and descriptions are preserved, and a row's booleanequalsrides on the row for the export - it does not change how the row joins into the URL; a"value": nullor absent value is what does, stored asvalueless: trueand joined as a barekey). Whenquery[]is absent or empty andrawcarries a query string,raw's query is parsed instead via the samequeryEntries- schema-legal and produced by hand-written or script-generated collections that populate onlyraw, where the query used to be discarded silently. Whenquery[]has entries it always wins, since it carries disabled state and descriptionsrawcannot. - Object url with no
raw(schema-legal, rare - most exports always writeraw):host_path_urlassembles a base fromprotocol(defaulthttps),host[](or a bare string) joined with., an optionalport, andpath[](string or{value}variable entries) joined with/. Aurl.hashis appended as#<hash>. Counted asurl_without_raw, informational rather than lossy - the URL is built, not dropped.
A query row holds raw query text (issue #1771), as a Postman row does: ?q=a%2Bb is the row a%2Bb, not a+b. Decoding first and re-encoding on the join is not lossless - %2B would become a + a server reads as a space, and %2541 would become %41 - so nothing is decoded and a literal % (?discount=50%, %ZZ) is kept byte for byte. The join (below) writes each enabled row with Postman's own query rule, core::encode_query_component: Postman's QUERY_ENCODE_SET (the C0 controls, DEL, every byte above ~ as UTF-8, space, ", #, ', <, >), plus & in a key or a value and = in a key. Everything else goes out as written - +, |, /, ?, :, [, ] and % - so an escape already in a row is never encoded twice, and a whole {{token}} is kept verbatim. ?q=a|b&r=c d is stored as ?q=a|b&r=c%20d, which is what Postman sends. An item with disableUrlEncoding joins its rows as written. The rule is pinned to the app's Params table by engine/tests/fixtures/query-encoding-conformance.json.
Path variables (url.variable[], issue #1764): the URL keeps its :name segments verbatim, and each url.variable[] entry becomes one of the request's own Params rows marked "in": "path" - key (a v2.0 entry naming itself by id alone is read by that name, as Postman's Url does), value (through normalize_template_vars), description, type and disabled kept, in the order the entry lists them. A :name the path spells that no entry declares gets no stored row, and neither does any :name of a string url (v2.0), which has no url.variable[]: the Params tab shows an empty row for it until it is edited, and an export writes url.variable[] only for rows that exist, so a round trip does not add an entry the source never had. A declared entry no segment uses is kept. Which segments are path variables is Postman's own rule (core::path_variable_segments): a whole path segment after the authority that starts with :, the name running to the first .. Nothing is promoted to a collection variable and nothing is counted: two requests on :id keep their own values, and composition writes each request's value into its segment at send time (see POST /compose).
The split is pmUrl's output, not the stored shape. parseImport rejoins each request's enabled query params (never a path row) onto its url afterwards, because that is where every execution path reads the query from - see The url/params invariant. So {{baseUrl}}/users?page=1&trace=1 with trace disabled parses to base + two params here, and is stored as {{baseUrl}}/users?page=1 with both params still in the table.
Body mapping¶
pmBody(body, ctx) switches on body.mode. A missing body or missing body.mode → { mode: "none" }. body.disabled: true ("prevent request body from being sent") is checked first and also imports as { mode: "none" } regardless of mode - counted as disabled_body (issue #1444) rather than sending a body the user had turned off.
A non-empty body on a GET or HEAD is mapped like any other and additionally counted as body_on_get (see Redirect settings): Postman does not send it, Vayu does.
Postman body.mode |
Vayu RequestBody |
Notes |
|---|---|---|
raw |
postman_raw_body(body.raw, body.options.raw.language) |
see raw sniffing below |
urlencoded |
{ mode: "x-www-form-urlencoded", fields } |
fields = mapKeyValues(body.urlencoded), a row's non-"text" type kept as on a header |
formdata |
{ mode: "form-data", fields } |
text entries via map_key_values, a non-empty contentType on one kept on the field (the engine sends it as that part's own Content-Type, issue #2539); a type: "file" entry becomes a file row per path in src (a string or an array - Postman allows several files per field), which the parse answer marks unresolved unless this machine already allows it. A file entry naming no path becomes one file row with src: "" (no file chosen), counted in meta.unattachedFileParts. |
graphql |
{ mode: "graphql", content } |
via graphqlContent - the graphql object is serialized to JSON with variables parsed (see below); operationName rides along, and the request gains a Content-Type (see below) |
file |
{ mode: "binary", file: { src, fileName } } |
src is body.file.src as written and fileName its base name; src: null or no file (Postman's shape before a file is chosen) imports as { src: "" }, no file chosen. Counted as file_body, a file reference to relink |
| anything else | { mode: "none" } |
GraphQL variables (graphqlContent): Postman stores body.graphql as { query, variables } where variables is the text of the Variables pane - a JSON-encoded string. Vayu's own serializeGraphQLBody writes variables as an object, and the engine sends the stored content verbatim, so the string is parsed here; embedding it as-is put "variables": "{\"limit\": 10}" on the wire (spec-invalid) and showed a double-escaped blob in the Variables pane. Two deliberate fallbacks: a variables string that is not valid JSON is kept as text (the pane text is the only copy of the user's work, so an import that deletes it is worse than one that shows it unparsed - and the pane now shows a string-typed variables verbatim rather than as an escaped blob, converting it to an object once an edit makes it parse), and an empty or whitespace-only string drops the key entirely, which is what Vayu writes for an empty pane. Every other key on the object rides along untouched.
GraphQL operationName: preserved verbatim, like every other key on the object. It names which operation in a multi-operation document to execute, and Vayu's GraphQL panes carry it through an edit and expose it as an operation picker above the query pane - so an imported request keeps running the operation it was imported with.
GraphQL Content-Type (with_required_content_type in import_document.cpp): a GraphQL body is a JSON envelope, so the request needs Content-Type: application/json - and Vayu's request builder adds that header only when you pick GraphQL, which an import never does. The header was therefore absent, and libcurl defaults to application/x-www-form-urlencoded, which most GraphQL servers answer with a 400; nothing in the app said why. The header is now written at import, by the engine's port of the rule the mode picker uses (contentTypeToAdd): a Content-Type the collection declares wins (including a deliberate application/graphql), and a disabled row does not count as declaring one. The row is written as the body mode's own ("source": "body-mode", the marker the Body panel writes), because Postman treats a body's Content-Type as a system header: a request whose disabledSystemHeaders refuses content-type gets no row at all, and a later opt-out in Vayu removes the marked row from the wire while a Content-Type the user typed is always sent (issue #1765). The export leaves the marked row out while Postman would add the same header on its own.
Raw language (postman_raw_body in import_document.cpp):
options.raw.language |
Result |
|---|---|
"json" |
{ mode: "json", content } |
"text" |
{ mode: "text", content } |
"xml" |
{ mode: "xml", content } - and the request gains Content-Type: application/xml through the same with_required_content_type rule GraphQL uses (above) |
"html", "javascript" |
{ mode: "text", content, rawLanguage } - and the request gains Content-Type: text/html / application/javascript as the body mode's own row ("source": "body-mode"), whatever the content looks like (HTML that happens to parse as JSON is still text/html) |
any other declared language ("yaml", ...) |
{ mode: "text", content, rawLanguage }, no row: sent as text/plain, as Postman sends it, even when the content parses as JSON |
| absent | tries JSON.parse(content); success → { mode: "json" }, failure → { mode: "text" } - with rawLanguage: "" beside it |
The language-to-type table is LANGUAGE_CONTENT_TYPES in postman_format.hpp,
beside RAW_LANGUAGES, and holds only the languages that need a row: json,
xml and text are modes the engine already sends under their own type.
The row follows the GraphQL rules: an enabled Content-Type the request
declares wins, a disabled one does not count, and a request whose
disabledSystemHeaders refuses content-type gets none.
rawLanguage is what the Postman export reads to write the body's options
back as the document had them: none at all for an unlabelled body (the common
shape in generated collections), the declared language otherwise.
postman_raw_body is the one mapping both directions call, so the exporter
writes a kept rawLanguage only while importing the body again would still
give its stored mode. The export leaves the html / javascript row out for
the same reason it leaves GraphQL's: Postman adds that header itself from the
language.
An unlabelled body still differs from Postman. Postman sends a body with no
declared language as text/plain; Vayu sniffs it, so JSON-looking content is
sent as application/json and the rest as text/plain. That is the one
place a body's wire type differs from Postman's. It is also never sniffed into xml:
without Postman's language, a <-shaped document is as likely to be HTML, and
guessing would hand the request a Content-Type the server may disagree with.
File references are imported, never dropped. A file body and every
formdata file entry keep the path the export named. A path names a file on
the exporting machine, so Vayu sends it only once you pick the file again in
the request, or once it lies under a folder you allowed in Settings > Files;
the parse answer marks each one this machine would refuse unresolved. Each file body is counted as
{ kind: "file_body", count, requests } - informational, the requests whose
body file to relink - and each file entry with no path as an
unattachedFileParts field to fill.
Auth mapping¶
Auth is mapped by mapPostmanAuth(auth) (import_document.cpp). It reads auth.type, then flattens the type-specific detail via authDetail(auth[type]).
Postman auth.type |
Vayu RequestAuth |
Notes |
|---|---|---|
(absent / no type) |
{ mode: "inherit" } |
|
bearer |
{ mode: "bearer", token } |
token normalized |
basic |
{ mode: "basic", username, password } |
both normalized |
apikey |
{ mode: "apikey", key, value, in } |
in = "query" only if detail in === "query", else "header" |
oauth2 |
{ mode: "oauth2", config: OAuth2Config } |
mapped via map_postman_oauth2 (import_document.cpp) - executable; grant normalized. tokenName, when present, is stored as config.credentialsId - Vayu's field for keeping otherwise-identical token-cache entries apart. A block holding only a seeded accessToken (no grant, token URL or auth URL - commercetools writes one on every request) is what Postman sends as is, so it imports as what sends the same bytes: a bearer token, or, when addTokenTo is queryParams or headerPrefix is not Bearer, an API key (access_token in the query, or Authorization: <prefix> <token>). A seeded accessToken beside an explicit grant (Vayu fetches a new one through the grant) is not used when sending and is counted as oauth2_dropped_field, named per request; state (Vayu generates and validates its own per authorization attempt) is counted apart as oauth2_state_regenerated, because it changes nothing sent (issues #1460, #2536). Both are kept in the block's postman source below, so an export writes them back. The extra request parameter lists are read as described below |
awsv4 |
{ mode: "aws", config } |
awsv4 is the schema's enum value for AWS Signature; Vayu's internal mode is aws, so the name is translated rather than passed through. Matching on "aws" here dropped every real SigV4 export to {mode:"none"} and suppressed the nonExecutableAuth warning. The mode is not executed: the request is sent without auth, and the send's authNotice says so (api-reference) |
digest / ntlm / hawk / oauth1 / edgegrid / jwt |
{ mode: type, config } |
config is the raw flattened detail map; not executed by Vayu - the request is sent without auth, and the send's authNotice says so (reported through nonExecutableAuth, as aws is - see counting). The table is CONFIG_AUTH_TYPES in postman_format.hpp, which the exporter reads too, so each exports back as its own type |
inherit |
{ mode: "inherit" } |
|
noauth |
{ mode: "none" } |
on a request; a collection/folder noauth is terminal - see below; this is the correct mapping, not a drop, so it is not counted |
a type the schema does not define / non-string type |
{ mode: "none" } |
counted as unsupported_auth |
The block itself, kept for the export (with_postman_source). When the
Postman exporter would not write a request's or collection's auth back
exactly as the document had it - an attribute Vayu has no field for
(tokenType, state, a parameter row it does not carry), a type stored as another mode
(the seeded-token oauth2 above), a different attribute order or attribute
type, {{ x }} spacing the importer tightened - the document's block is
stored beside the mapped auth as postman, in v2.1 form (a v2.0 detail object
becomes the attribute array Postman's own conversion writes). Nothing sends
it. The exporter writes it back verbatim, key order restored, while mapping it
through map_postman_auth again still gives the stored auth; once the auth is
edited in Vayu the block no longer describes it and the stored auth is written
instead; the engine drops it from the stored auth at that same write, so the
credential an edit replaced does not stay behind in it. Its credentials are
blanked like any other when an export leaves credentials out, including the
PKCE code_verifier and the credential rows (client_secret,
client_assertion, refresh_token and the like) of an oauth2 block's
tokenRequestParams, authRequestParams and refreshRequestParams.
authDetail - v2.1 array vs v2.0 object: Postman stores auth detail either as an array of { key, value } entries (v2.1) or as a plain object (v2.0). authDetail handles both: arrays are folded into a { key: value } map (skipping entries without key); objects have every entry coerced to a string. The result is the same flat string map regardless of source version, so the rest of map_postman_auth is version-agnostic.
Collection / folder vs request inherit rules:
- Requests keep
map_postman_authoutput verbatim -inheritis a valid mode for aRequestDraftand is resolved at execution time. A request's ownnoauthbecomes{ mode: "none" }, which already means "send nothing" for a request. - Collections and folders go through
collectionAuth, which distinguishes two states Postman keeps apart:
Postman collection/folder auth |
CollectionDraft.auth |
Inheritance |
|---|---|---|
absent, or {"type":"inherit"} |
{ mode: "none" } |
transparent - a descendant's inherit keeps climbing |
{"type":"noauth"} (explicit No Auth) |
{ mode: "noauth" } |
terminal - descendants send no credentials |
| any concrete type | that mode | the descendant inherits it |
Collections never inherit (CollectionDraft.auth excludes inherit), which is why inherit collapses to none. The explicit-noauth case must not collapse with it: the resolution walk steps over none, so a request set to Inherit inside a No Auth folder used to resolve to the root collection's credentials - sending a bearer token to the endpoints the user had marked unauthenticated. The terminal mode is read by resolveAuthSource (renderer) and composeAuth (MCP); see variable resolution → auth inheritance.
nonExecutableAuth counting: nonExecutableAuth counts the requests that go out without their auth, and the other members say where it is declared. One pass over the finished draft tree (find_data_only_auth) resolves each request's mode the way a send does, keyed off the mapped mode (so awsv4 counts as aws): a request with its own mode uses it, one set to Inherit takes the nearest ancestor's concrete mode, a folder's or collection's none is transparent and its noauth is terminal. A request whose resolved mode is in CONFIG_AUTH_TYPES (aws, digest, ntlm, hawk, oauth1, edgegrid, jwt) counts and is named in nonExecutableAuthRequests, in document order. The folders that declare such an auth themselves are named in nonExecutableAuthFolders and the root collection's name is nonExecutableAuthCollection; neither is counted as a request, and the preview names them in a "set on ..." clause beside the request line. A request set to No Auth under a data-only folder is not counted; a request inheriting through a transparent folder is. oauth2 is executable and never counts. Insomnia counts the same way, through the same pass (#2610; Insomnia v4).
OAuth 2.0 extra request parameters¶
Postman keeps an oauth2 block's "Advanced" parameters as three attributes,
tokenRequestParams, authRequestParams and refreshRequestParams, each an
array of {key, value, enabled, send_as} rows (send_as is request_body,
request_url or request_header; none means the body). map_postman_oauth2
reads them from the raw detail block, in either schema shape, in that order
(issue #2536):
- A row Postman has switched off (
enabled: false) is not read. - An
audienceorresourcerow of the token or authorization list sent in the body becomesconfig.audience/config.resource, which the engine already sends in both requests. The first such value wins; a later row of the same name with a different value is carried in its own list instead. - Every other row is carried in the config list of its request,
tokenParams,authorizationParamsorrefreshParams, as{key, value, enabled: true, sendAs}withsendAsbody,urlorheader. AnauthorizationParamsrow stores nosendAs: the authorization request is a browser navigation, so its parameters ride in the authorize URL's query. A value is kept as typed,{{ x }}tightened as every imported value is. - A row with no key, a
send_asVayu has no target for, or a key the engine writes itself (grant_type,client_id,client_secret,code,redirect_uri,code_verifier,refresh_token,username,password,scope,state,code_challenge,code_challenge_method,response_type:RESERVED_PARAM_NAMESinoauth_client.hpp) is not carried and is counted asoauth2_unmapped_param. The count names its requests and, undernames, the parameter keys; a value is never recorded, since it can be a credential. The Preview shows it as an amber line naming the request and the keys. A savedaccessToken(oauth2_dropped_field) is a muted note that the grant fetches a new token, and a regeneratedstate(oauth2_state_regenerated) is not shown: nothing sent changes.
The token cache key reads credentialsId and not audience or resource, so
two imported requests differing only in their audience would share one cached
token. When a block names no tokenName, the promoted audience (else the
resource) is stored as config.credentialsId to keep them apart. (A carried
row is read by the key itself, so two audiences sent as rows are two tokens
already.)
The export writes the lists back as Postman's three attributes, each row with
its send_as (an authorizationParams row as request_url), and
config.audience / config.resource as request_body rows opening
tokenRequestParams, where the next import promotes them from again. A
credentialsId equal to what the import derived is not written as a
tokenName, so import -> export -> import gives back the same config.
Variables & environments¶
Collection- and folder-level variable[] arrays map to CollectionDraft.variables via to_var_record:
- entries without a
keyare skipped; - enabled state is
!disabledifdisabledis set, elseenabledif set, elsetrue; - the value is coerced to a string (
as_string) and run throughnormalize_template_vars; type: "secret"setssecret: true;"string","number"and"boolean"are Vayu's own variable types and are stored astype(a script reads anumbervariable as a number, as in Postman);"default"is Postman's unset marker and stores nothing;- a
descriptionis stored on the variable for the Postman export to write back (the variables editor does not show it); - any other declared
type("any", a custom string) has no Vayu counterpart and is dropped, counted once per row asvariable_metadata; - each row is stamped
createdAt, one clock reading per import plus its position in the array (issue #3252). The stored variables object keeps its keys in name order, so the stamp is what carries the file's order: the variables editor and the collection tab's context-bar section list a scope bycreatedAt(lib/variable-order.ts).
Postman collection files do not embed environments, so this parser always returns environments: [] and meta.environmentCount: 0. Postman exports environments as separate files, which import_document.cpp reads.
Options & lossy behavior¶
importScripts is honored: when opts.importScripts is false, pm_request and pm_folder write no script elements (the set_event_elements call is gated behind the flag). When true, each event's script.exec array is joined with \n by join_exec (or its string form is used, else ""; a script that is itself a string is used as the text). importEnvironments is accepted but unused by this parser (no environments to import).
Not carried by design, and not counted: a collection's info.version and the ids Postman stamps on a collection, folder, request or event (info._postman_id, item[].id, event[].id, script.id). They identify a copy inside Postman's workspace, Vayu mints its own ids, and nothing reads them back, so there is nothing to lose that a person would finish by hand.
meta.skipped - this parser populates: file_body (file-mode bodies, imported as binary file references to relink - not a loss), malformed_item (non-object item[]/event[] entries, and a saved response that is not an object or whose numeric code is not an integer from 200 to 599), unsupported_method (a custom HTTP verb, falls back to GET), unsupported_auth (an auth type the schema does not define, or a non-string type, falls back to no auth), oauth2_dropped_field (a pre-fetched accessToken beside an explicit grant config, named per request - see Auth mapping), oauth2_state_regenerated (an oauth2 block's state, which Vayu regenerates per authorization attempt; nothing sent changes), oauth2_unmapped_param (an OAuth 2.0 extra request parameter not carried, with its key under names - see OAuth 2.0 extra request parameters), url_without_raw (informational - a URL shape that was mapped rather than dropped, see URL handling), variable_metadata (a variable type Vayu has no counterpart for - "any" or a custom string - or an environment or globals variable's description), disabled_body (a request body whose own disabled was true - see Body mapping), certificate (a request's own certificate the engine could not resolve into a client_certificates registry candidate - no cert.src/key.src, an unreadable file, an unresolved {{var}} host, or a second, different certificate for a (host, port) an earlier request in this import already claimed; a resolvable one is offered in the preview and applied only when ticked - the preview adds the ones left unticked to this count, see the field table above and issue #1656), protocol_behavior (a request's protocolProfileBehavior key Vayu stores but does not apply, or host / content-length in its disabledSystemHeaders - see Redirect settings), protocol_behavior_folder (the same, declared on a folder or the collection, counted once per declaring node with its name under names), body_on_get (a GET or HEAD request whose body is not empty and whose resolved disableBodyPruning is not true, named per request - Postman does not send that body and Vayu does, see Redirect settings), proxy_config (a request's own proxy override - there is no per-request proxy mechanism to import it into, and none is planned, so this tally is permanent), and script_unsupported (an enabled event with a script.src, or with script text under a listen other than prerequest / test, which has no element to become; one per event, with the request, folder or collection that declares it under requests - see Scripts). It does not emit websocket, grpc, api_spec, or unit_test items.
meta.unsupportedScriptApis - [{request, names}], present only when non-empty (no other importer sends it, and it is not a meta.skipped kind: it carries a list per subject, which ImportTally cannot hold). request is the request's name, or the folder's or collection's (info.name) for a script declared there; names are the table's spellings (require(), cheerio, script.packages, pm.test.skip, fetch, pm.cookies.set, console.debug, ...), deduplicated and in table order, across all of that subject's scripts. Entries follow the walk: a folder's requests, then the folder, then the collection last, as with nonExecutableAuthRequests. A request name used twice is listed twice - they are different requests. See Scripts.
meta.nonExecutableAuth - populated: the number of requests whose resolved auth mode is data-only, named in meta.nonExecutableAuthRequests; meta.nonExecutableAuthFolders (sub-folder names) and meta.nonExecutableAuthCollection (the root collection's name) report the declaring sites, each present only when there is one. The rule is stated once, under nonExecutableAuth counting. These auths are stored on the draft (with their config) but Vayu has no execution path for them.
Shared helpers used¶
All defined in engine/src/core/import_document.cpp (except normalize_template_vars, which is engine/src/core/path_template.cpp); see the index for full reference.
| Helper | Use in this parser |
|---|---|
as_string |
coerce any scalar to its string form (values are stored as strings) - used inside to_var_record/authDetail |
to_var_record |
collection/folder variable[] → CollectionDraft.variables |
map_key_values |
header[], query[], urlencoded[], formdata[] → KeyValueEntry[] (preserves disabled + duplicates) |
map_postman_auth |
auth object → RequestAuth (request and, via collectionAuth, collection/folder) |
postman_raw_body |
raw-mode body → RequestBody: a declared language maps to its mode or to text (kept as rawLanguage), an unlabelled body is sniffed for JSON (shared with the exporter) |
join_exec |
event.script.exec → joined script string |
normalize_template_vars |
rewrite {{ x }} / {{ _.x }} template syntax to Vayu {{x}} (path_template.cpp); applied to URLs, values, vars, and auth fields. Called without pathTemplates, so a literal single-brace {x} is left alone - in Postman only {{x}} is a template, and rewriting /tags/{beta} or fields=friends{name} invented a variable that resolved to nothing |
Exporting to Postman¶
The way back is an export, not a parse: any collection writes out as a Postman
Collection v2.1 file, from its ⋯ menu in the sidebar (Export as Postman
Collection) or from the Spec tab's Export menu (Postman Collection
v2.1…). The engine assembles the document
(POST /export/postman) from what is stored - folders, requests, variables,
auth and scripts - and the dialog offers Copy or Download, saving
<collection name>.postman_collection.json. Nothing is sent anywhere, and
nothing is written: an export is a read of what the collection already is.
A JSON-RPC body is exported as the frame Vayu sends (issue
#3244). Postman has no JSON-RPC
mode, so the body is written as raw JSON, with the jsonrpc and id members
Vayu adds on send already in it; a body that already carries a full frame is
written unchanged. The export still counts it under jsonrpc_bodies.
Credentials stay out by default. With Include credentials off, auth
secrets and variables marked secret are written empty, and so are the
credentials typed outside an auth block: a request header such as
Authorization or X-Api-Key (and the API-key auth's own header), a query
parameter such as api_key or signature in the Params rows and the URL, the
password in a URL's user:pass@, and on every saved example the recorded
request's headers and URL, the response's sensitive headers (a Set-Cookie
row in full) and the value of every cookie. The dialog says how many. Request
and response bodies and scripts are not checked and are written as they
are, which the dialog also says. Turn it on to write everything as stored,
which is what Postman's own export does - only for a file that stays with you.
Saved responses come back as they were recorded. An example imported from
Postman keeps the request it was recorded against, its status text, preview
settings, cookies and response time, and exports with them. Change its status or
headers (through the API or an MCP agent) and the export writes that change, regenerating the status text,
header rows and preview settings that described the old value. The cookies are
rebuilt only when a Set-Cookie header changes, so a cookie whose Set-Cookie
header you removed is not exported, while fixing an unrelated header keeps the
cookies as recorded; the recorded request stays as recorded.
A response you save as an example keeps the request that produced it
(issue #1763). Save as example on a response you just sent records the
request as it was when you pressed Send - method, URL, params, headers and
body, with {{variables}} left unresolved and auth left out - together with
the server's own status text, the response's cookies (a Max-Age counted from
when the response arrived) and its response time.
The saved headers are one row per header line the server sent, in its case and
order, so two Set-Cookie lines are two rows and two real cookies in the
export's cookie[], not one row holding both. A body the engine stopped reading
at the Send response cap (Max Send response body in Settings) saves as partial,
the same Partial body flag a body shortened for storage gets, and the dialog
says so before you save.
The export writes those back, so editing the request afterwards does not change
what the example says it was sent with. A value typed literally into a header
or the URL at Send stays in that example after you remove it from the request;
with Include credentials off it is exported empty, by the same name rules as
a header on the request itself, and counted. A streamed response keeps the
record too: the copy the app reloads when the stream ends is matched to the
Send that started it. An
example saved before this, or from a response the app fetched without a Send
of its own to match it to (the last run shown again after a restart, or a
response opened from History), has no such record and exports regenerated from
the request as it is at export time.
A typed auth header wins, and the export says so. When a request has its own
Authorization (or the API key's header) typed in Headers, Vayu sends that
header and skips the auth. Postman does the opposite - its auth overwrites the
header - so such a request is exported with No Auth, which makes Postman
send what Vayu sends. The dialog counts these requests; a folder's or the
collection's auth is left as it is.
What Postman has no place for is listed, not dropped. Before you download, the dialog states how many requests and folders the file carries and names each kind of thing the export could not carry, with a count, in the engine's words.
A form-data part exports with its own contentType when it has one, a text
part as well as a file part.
A binary body exports as Postman's file mode naming the file's path
(file.src), as a form-data file part names its own; a file's own content type
or a file name other than its path's has no place in that mode and is listed.
An agent can ask for the same document over MCP (export_postman), which always
leaves credentials out.
What an imported collection gives back as Postman wrote it. The import
keeps, beside what Vayu uses, what the export needs to write a Postman document
back unchanged: every event in its order, a disabled one still disabled; a raw
body's declared language, or its absence (rawLanguage); a header's
type: "default" and a query row's equals; a request's path variables
(issue #1764), which export as the :name segments of raw and path[] and
their rows as url.variable[] (key, value, then a type and
description the import kept, and disabled), written after the query rows
and never into query[]; a variable's string / number
/ boolean type and its description; an item-level description; and the
document's own auth block whenever the mapped auth alone would not give it
back (auth.postman) - an oauth2 block holding only a seeded token, the
attributes Vayu has no field for, attribute order and types, and the
Hawk, OAuth 1.0, EdgeGrid and JWT types Vayu keeps as data. Each is written
back only while it still describes what Vayu holds; after an edit in Vayu the
export writes the edit.
What still comes back differently, and why:
- Method case. A
getorposttyped in lower case exports upper case. Vayu stores the method as one of its seven verbs, and both Postman's runtime and Vayu's composer send it upper-cased, so the wire is the same. url.rawis rebuilt from the stored URL: the query rows Postman sends (a stalerawa generator left without an enabled row gains it), encoded by Postman's own query rule, so a reserved character (filter[type],a|b) comes back as written. One difference remains. A space or non-ASCII character typed intorawcomes back percent-encoded (c%20d), because Postman'srawholds the typed text and Vayu stores the wire form. An empty value comes back askey=and a"value": nullrow as a barekey, as Postman writes them: the row keeps the null asvalueless: true. Thequery[]rows themselves come back as written, a null value asnull. A pair the stored URL sends that no enabled row states (a request created through the API or MCP with its query only inurl) is added toquery[]after the rows, in URL order, read by the same splitter the import uses (split_query_pairs): Postman and Newman readquery[]overraw, so leaving it out would drop the pair from the sent request. Re-importing such an export gives the request the rows it lacked and the URL it had.- Variable order within a collection or folder follows name order, the order the stored variables object keeps.
- A folder's or the collection's
protocolProfileBehavioris not written back at the level it was declared on. The import flattened its applied settings onto the requests below it, so they come back as request-level keys (generated, or reconciled into the request's own object by the rule below); a key Vayu does not apply (insecureHTTPParser, a TLS option) is counted at import and not carried, because there is no folder-level carrier. protocolProfileBehavioris written back as imported, member order and every key included, while it agrees with the request's settings; a setting edited in Vayu since is written over its key in place (or appended), and a changeddisabledSystemHeadersis rewritten as{name: true}in stored order. A request with no imported object gets one generated in the orderstrictSSL, followRedirects, maxRedirects, disableUrlEncoding, disableCookies, disabledSystemHeaders, disableBodyPruning.disableBodyPruningstays as imported, except on a GET or HEAD that has a body: Postman strips such a body unless told not to, so an imported object withoutdisableBodyPruning: truegets it (in place, or appended). An untouched import with no body is written back unchanged.- Empty-name rows (a disabled header with no key, an editor's trailing blank row) are not imported.