Convert CSV to JSON for Postman Collection Runs

Default settings. Each object is one iteration; age is a number and active a boolean, so typed assertions pass.

Input (testdata.csv):
email,age,active
a@x.com,36,true
b@x.com,54,false

Output (array, inference on):
[
  { "email": "a@x.com", "age": 36, "active": true },
  { "email": "b@x.com", "age": 54, "active": false }
]

// In a test: pm.expect(pm.response.json().age).to.eql(Number(pm.iterationData.get('age')))

Use the downloaded array as Newman's data file. One iteration per array element.

Output saved as data.json (array of N objects)

newman run collection.json -d data.json
→ runs N iterations, {{email}} {{age}} {{active}} bound per row

A literal null cell becomes JSON null, so you can drive a negative test that sends a null field and asserts the API's validation error.

Input:
name,phone
Ada,null

Output:
[ { "name": "Ada", "phone": null } ]

// pm.test('rejects null phone', () => pm.expect(pm.response.code).to.eql(422))

Use the converted object as the JSON body of a POST under test. Numbers and flags are already typed, so the API sees a realistic payload.

Output element used as body:
{ "sku": "A-1", "qty": 3, "giftWrap": true }

// Request body (raw JSON), referencing iteration vars:
{ "sku": "{{sku}}", "qty": {{qty}}, "giftWrap": {{giftWrap}} }

Order IDs with leading zeros must stay verbatim. Turn inference off so {{orderId}} is the exact string.

Input:
orderId,total
00087,19.99

Output (inference OFF):
[ { "orderId": "00087", "total": "19.99" } ]
→ {{orderId}} resolves to "00087"

With a CSV data file, {{active}} is the string "false", which is truthy in JavaScript — so if (pm.iterationData.get('active')) runs the true branch even when the value is false. Converting to JSON with inference on makes it a real boolean, so the condition behaves correctly. This is the single biggest reason to use a JSON data file.

Inference turns 00087 into 87. If {{orderId}} must keep its zeros for the request, turn off Infer numbers, booleans, null so it stays a string. Inference is global, so the trade-off is that genuinely numeric vars also become strings — wrap them in Number(...) in your scripts if needed.

A blank cell becomes ""; only the literal word null becomes JSON null. For a negative test that must send a true null, put null in the CSV cell. To send no field at all (testing 'missing required field'), turn on Skip empty cells so blank cells omit the key entirely.

Two columns named id collapse to one JSON key (later wins), so one of the iteration values is lost. Rename one column before converting so both variables exist in each iteration object.

In a raw JSON request body, "qty": "{{qty}}" always sends a string because of the quotes. To send a number, write "qty": {{qty}} (no quotes) and ensure the data file has a real number — which inference provides. The converter gives you the typed value; the body template controls how it is injected.

With Skip empty cells on, a blank cell drops the key — so pm.iterationData.get('x') returns undefined for that iteration. If your tests expect the key to always exist (as an empty string), leave Skip empty cells off.

Free tier caps at 2 MB / 500 rows — usually plenty for a data-driven test, since Runner iterations rarely number in the thousands. For a large soak/load fixture, Pro raises it to 100 MB / 100,000 rows. Newman has no inherent iteration limit; the constraint is the converter tier here.

A header User Name becomes the key User Name (spaces preserved). {{User Name}} still works in requests, and in scripts use pm.iterationData.get('User Name'). If you prefer dot access, rename the column to userName in the source CSV before converting.