How to find the size of a json object?

[muhamedsuhail]

I am trying to limit the size of the JSON object to 16KB. Is it possible to check the size of the JSON object and cap it to 16KB?

[nlohmann]

• What would be measured? The memory footprint? The number of bytes needed to serialize the object?
• When should the size be enforced? While parsing?

[muhamedsuhail]

This is my requirement. I need to cap the JSON object to 16kb. I am dumping the JSON object as a value in a text file.

[nlohmann]

As a hack, you could call j.dump().size() which creates a string representation and then asks for the size in bytes. If this is too inefficient, you could write your own recursive function to traverse the JSON object - see the implementation of size() for an example.

[muhamedsuhail]

Thank you, Neils! I decided to write my own function.

[DUOLabs333]

I have a similar question, due to trying to track down the cause of a stack overflow --- I specifically want the size of the json object (along with all its sub objects, etc.) in memory.

[gregmarr]

You're looking for stack size, in that case, which is pretty much fixed at 16 for a local variable. All storage underneath that is going to be heap storage, and not affect your stack overflow.

[amdjachenko]

I need to use http bulk API that limits the size of json text representation I can send. So I would like to have an efficient way of doing something like upper_bound_size function with the same signature as dump but not allocating/faster than dump().size()

json bulk;
size_t upperBound = 0;

for (const auto& event : json_events)
{
    upperBound += event.upper_bound_size();
    if (upperBound < threshold)
        bulk.push_back(event);
    else
        break;
}

send(bulk);

[coderaviverma]

What you want to limit is not the in-memory object size, but the serialized size (i.e. how many bytes it occupies when written or transmitted).

That means the correct unit is UTF-8 byte length of the serialized JSON string.

✅ Correct approach (language-agnostic concept)

1. Serialize the JSON object
2. Measure its byte length
3. Reject or trim if it exceeds 16KB

✅ Example (JavaScript / Node.js)

const json = { /* your object */ };

const serialized = JSON.stringify(json);
const sizeInBytes = Buffer.byteLength(serialized, 'utf8');

if (sizeInBytes > 16 * 1024) {
  throw new Error("JSON payload exceeds 16KB limit");
}

✅ Browser-compatible approach

const serialized = JSON.stringify(json);
const sizeInBytes = new TextEncoder().encode(serialized).length;

This matches:

• Network payload size
• File storage size
• API / DB limits

⚠️ Important clarifications

• object.length or property count ❌ is meaningless
• string.length ❌ is not byte-accurate (UTF-16 vs UTF-8)
• Unicode characters increase byte size
• Compression (gzip) should not be used for validation

✅ Best practice
Enforce the size after serialization but before storage or transmission.
This is exactly how API gateways, Kafka, and databases validate payloads.

[gregmarr]

This same answer was already provided more than 5 years ago, and this is a C++ library, so Javascript solutions are not helpful.