JSON

The native JSON object is not available in SFMC SSJS — JSON.parse and JSON.stringify both throw. Use the SFMC-proprietary Platform.Function.ParseJSON and Platform.Function.Stringify (or the Stringify global) instead.

Status legend

Icon	Meaning
✅ Works	Available and behaves as expected
⚠️ Partial	Available but with a documented caveat or bug
❌ Missing	Not available — use the workaround

Members

Member	ES	Status	Notes
`JSON.parse(text)`	ES5	❌ Missing	Use `Platform.Function.ParseJSON`
`JSON.stringify(value)`	ES5	❌ Missing	Use `Platform.Function.Stringify` or the bare-name `Stringify` Core global

parse

(ES5) — ❌ Missing. JSON.parse is not available. Use Platform.Function.ParseJSON(string), which parses a JSON string into an SSJS object. Coerce the input to a string first (str + "") to avoid CLR/JS boundary issues.

// ❌ Not available in SFMC:
// var obj = JSON.parse(jsonString);

// ✅ Use Platform.Function.ParseJSON:
var jsonString = '{"name":"Jane","age":30}';
var obj = Platform.Function.ParseJSON(jsonString + "");
Write(obj.name);   // "Jane"

See Platform.Function.ParseJSON for full details.

Show test script

<script runat="server">
Platform.Load("core", "1.1.5");

/*
 * Chapter: parse — JSON.parse is missing; use Platform.Function.ParseJSON
 *
 * Proves:
 *   1. DEVIATION marked "DEV": the native JSON object is MISSING.
 *      typeof JSON is "undefined" (spec/ES5: "object"), and JSON.parse
 *      throws "Object expected: parse" when invoked.
 *      NOTE: merely READING JSON.parse does not throw — Jint resolves the
 *      whole member path to undefined; only the CALL throws.
 *   2. The documented workaround works: Platform.Function.ParseJSON(str + "")
 *      parses a JSON string into an SSJS object, and obj.name is "Jane".
 *   3. Round-trips with deterministic fixtures: nested objects, arrays,
 *      null, booleans, numbers, escaped quotes and non-ASCII characters all
 *      survive Stringify -> ParseJSON unchanged.
 *   4. Documented edge cases of ParseJSON: a top-level JSON array yields an
 *      indexable array; a SCALAR JSON value comes back as a STRING, not a
 *      number/boolean/null; and invalid, empty, null or undefined input
 *      returns null WITHOUT throwing.
 *
 * EXPECTED OUTPUT: every line starts with PASS. A FAIL means the runtime no
 * longer matches the documented claim and the page must be revised.
 */

function assert(id, actual, expected) {
    Platform.Response.Write((actual === expected ? "PASS " : "FAIL ") + id + " -> [" + actual + "]\n");
}
function assertThrows(id, fn) {
    var threw = false, msg = "";
    try { fn(); } catch (ex) { threw = true; msg = ex.message; }
    Platform.Response.Write((threw ? "PASS " : "FAIL ") + id + " -> " + (threw ? "threw: " + msg : "did NOT throw") + "\n");
}

/* 1. DEVIATION — the native JSON object does not exist. */
try {
    assert("DEV typeof JSON is undefined (spec: object)", String(typeof JSON), "undefined");
} catch (e1) { Platform.Response.Write("FAIL typeof JSON -> THREW: " + e1.message + "\n"); }
try {
    assert("DEV reading JSON.parse yields undefined (spec: function)", String(typeof JSON.parse), "undefined");
} catch (e2) { Platform.Response.Write("FAIL read JSON.parse -> THREW: " + e2.message + "\n"); }
assertThrows("DEV JSON.parse('{\"a\":1}') throws (spec: returns an object)", function () { return JSON.parse('{"a":1}'); });

/* 2. Workaround from the page: Platform.Function.ParseJSON with a coerced string. */
try {
    var jsonString = '{"name":"Jane","age":30}';
    var obj = Platform.Function.ParseJSON(jsonString + "");
    assert("ParseJSON result is an object", String(typeof obj), "object");
    assert("ParseJSON(...).name is 'Jane'", String(obj.name), "Jane");
    assert("ParseJSON(...).age is 30", String(obj.age), "30");
} catch (e3) { Platform.Response.Write("FAIL ParseJSON basic -> THREW: " + e3.message + "\n"); }

/* 3. Round-trip with a deterministic mixed fixture. */
try {
    var fixture = { n: 1.5, s: "x\"y", b: true, z: null, arr: [10, 20, 30], nested: { deep: "ok" }, uni: "caf\u00e9" };
    var round = Platform.Function.ParseJSON(Platform.Function.Stringify(fixture) + "");
    assert("round-trip number survives", String(round.n), "1.5");
    assert("round-trip escaped quote survives", String(round.s), 'x"y');
    assert("round-trip boolean survives", String(round.b), "true");
    assert("round-trip null survives", String(round.z), "null");
    assert("round-trip array element survives", String(round.arr[2]), "30");
    assert("round-trip nested object survives", String(round.nested.deep), "ok");
    assert("round-trip non-ASCII character survives", String(round.uni), "caf\u00e9");
    assert("round-trip non-ASCII length is 4", String(round.uni.length), "4");
} catch (e4) { Platform.Response.Write("FAIL round-trip -> THREW: " + e4.message + "\n"); }

/* 4. Documented ParseJSON edge cases. */
try {
    var list = Platform.Function.ParseJSON('[10,20,30]');
    assert("ParseJSON of a top-level array is indexable", String(list[1]), "20");
} catch (e5) { Platform.Response.Write("FAIL ParseJSON array -> THREW: " + e5.message + "\n"); }
try {
    var scalar = Platform.Function.ParseJSON('42');
    assert("ParseJSON('42') returns a STRING, not a number", String(typeof scalar), "string");
    assert("ParseJSON('42') value is '42'", String(scalar), "42");
} catch (e6) { Platform.Response.Write("FAIL ParseJSON scalar -> THREW: " + e6.message + "\n"); }
try {
    assert("ParseJSON of malformed input returns null (it does NOT throw)", Platform.Function.ParseJSON("{not json") === null, true);
} catch (e7) { Platform.Response.Write("FAIL ParseJSON malformed -> THREW: " + e7.message + "\n"); }
</script>

stringify

(ES5) — ❌ Missing. JSON.stringify is not available. Use Platform.Function.Stringify(value) (no Platform.Load needed) or the Stringify global (requires Platform.Load("Core", "1")).

// ❌ Not available in SFMC:
// var text = JSON.stringify(obj);

// ✅ Use Platform.Function.Stringify:
var obj = { name: "Jane", age: 30 };
var text = Platform.Function.Stringify(obj);
Write(text);   // '{"name":"Jane","age":30}'

// ✅ Or the Stringify global (after Platform.Load):
var text2 = Stringify(obj);

See Platform.Function.Stringify and Stringify for full details.