Raw body (text, XML) in Postman - Deep Dive

Overview - Raw body (text, XML)

What is it?

Raw body in Postman is a way to send data in HTTP requests exactly as you type it, without any automatic formatting. You can write plain text, XML, JSON, or other formats directly in the request body. This lets you test APIs that expect specific data formats or structures. Using raw body helps you control the exact content sent to the server.

Why it matters

Without raw body support, testers would struggle to send precise data formats required by many APIs, especially XML or custom text. This would make testing unreliable or impossible for APIs that need exact input. Raw body lets you simulate real client requests exactly, ensuring the API behaves correctly with real-world data. It helps catch bugs early and improves API quality.

Where it fits

Before using raw body, you should understand basic HTTP requests and how APIs work. After mastering raw body, you can learn about automated API testing, scripting in Postman, and validating responses. Raw body is a foundation for advanced API testing techniques.

Mental Model

Core Idea

Raw body lets you send exactly the data you want in an HTTP request, without any changes or formatting by the tool.

Think of it like...

It's like writing a letter by hand instead of using a form letter template; you control every word and space exactly as you want.

┌───────────────┐
│ HTTP Request  │
│  ┌─────────┐  │
│  │ Headers │  │
│  └─────────┘  │
│  ┌─────────┐  │
│  │ Raw Body│  │
│  │ (text,  │  │
│  │  XML)   │  │
│  └─────────┘  │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding HTTP Request Bodies

Concept: Learn what a request body is and why it matters in HTTP requests.

When you send data to a server using HTTP methods like POST or PUT, the data goes in the request body. This body can contain information like form data, JSON, XML, or plain text. The server reads this data to perform actions like creating or updating resources.

Result

You understand that the request body carries the main data payload in many API calls.

Knowing that the request body is where data lives helps you realize why controlling its content is crucial for testing.

2

Foundation

What is Raw Body in Postman

Concept: Raw body means typing the request data exactly as you want it sent, without automatic changes.

In Postman, you can choose 'raw' in the body tab and type any text, XML, JSON, or other formats. Postman sends this data exactly as you wrote it. This is different from form-data or x-www-form-urlencoded, which encode data automatically.

Result

You can send any custom data format to the server.

Understanding raw body lets you test APIs that require precise data formats, which other body types can't handle.

3

Intermediate

Sending Plain Text with Raw Body

🤔Before reading on: do you think sending plain text requires special headers or formatting? Commit to your answer.

Concept: You can send simple text as raw body without extra formatting, but headers matter.

Type any text in the raw body tab, like 'Hello API'. To help the server understand, set the 'Content-Type' header to 'text/plain'. Without this header, the server might misinterpret the data.

Result

The server receives exactly 'Hello API' as the request body and knows it's plain text.

Knowing to set the correct Content-Type header ensures the server processes your raw text correctly.

4

Intermediate

Crafting XML Payloads in Raw Body

🤔Before reading on: do you think XML in raw body needs special syntax or escaping in Postman? Commit to your answer.

Concept: You can write XML directly in raw body, but it must be well-formed and accompanied by the right headers.

Write XML like: User Tester Hello Set 'Content-Type' header to 'application/xml' or 'text/xml'. Postman sends this as-is.

Result

The server receives the exact XML document and can parse it properly.

Understanding XML structure and headers prevents errors when testing XML APIs.

5

Intermediate

Setting Content-Type Headers Correctly

🤔Before reading on: do you think Postman sets Content-Type automatically for raw body? Commit to your answer.

Concept: Postman does not always set Content-Type for raw body; you must set it manually to match your data format.

After choosing raw body, select the data format from the dropdown (Text, JSON, XML, etc.). Postman may set Content-Type accordingly, but verify it. If missing or wrong, add or edit the header manually to avoid server errors.

Result

Your request headers correctly describe the body format, ensuring proper server handling.

Knowing to check and set headers avoids common API testing failures.

6

Advanced

Using Raw Body for Complex API Testing

🤔Before reading on: do you think raw body can handle dynamic data or variables? Commit to your answer.

Concept: Raw body supports variables and scripting in Postman to create dynamic requests.

You can insert variables like {{userId}} in raw body text or XML. Postman replaces these with actual values at runtime. This lets you test APIs with changing data without rewriting the body each time.

Result

Your tests become flexible and reusable with dynamic raw bodies.

Understanding variable substitution in raw body unlocks powerful automated testing capabilities.

7

Expert

Common Pitfalls and Debugging Raw Body Issues

🤔Before reading on: do you think a malformed XML in raw body always causes clear errors? Commit to your answer.

Concept: Malformed raw body data can cause subtle server errors or unexpected behavior, requiring careful debugging.

If your XML or text is not well-formed, the server might respond with generic errors or ignore parts of the data. Use Postman's console to inspect the exact request sent. Validate XML with external tools before sending. Also, check headers and encoding to avoid silent failures.

Result

You can identify and fix raw body issues that cause test failures or false positives.

Knowing how to debug raw body problems saves time and improves test reliability.

Under the Hood

When you select raw body in Postman, the tool sends the exact bytes you typed as the HTTP request payload. It does not encode or transform the data unless you use variables or scripts. The Content-Type header tells the server how to interpret these bytes. The server reads the raw stream and parses it according to the declared format (e.g., XML parser for application/xml).

Why designed this way?

Raw body was designed to give testers full control over the request payload, because many APIs require precise formats that automated encoding can't handle. Alternatives like form-data or urlencoded are convenient but limited. Raw body supports any format, making Postman flexible for all API types.

┌───────────────┐
│ Postman Client│
│  ┌─────────┐  │
│  │ Raw     │  │
│  │ Body    │  │
│  └─────────┘  │
│      │        │
│      ▼        │
│  ┌─────────┐  │
│  │ HTTP    │  │
│  │ Request │  │
│  └─────────┘  │
│      │        │
│      ▼        │
│  ┌─────────┐  │
│  │ Server  │  │
│  │ Parser  │  │
│  └─────────┘  │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does Postman automatically set the correct Content-Type header for raw XML? Commit yes or no.

Common Belief: Postman always sets the correct Content-Type header when you choose raw body and XML format.

Reality: Postman may not set or may set an incorrect Content-Type header; testers must verify and set it manually.

Why it matters: If the Content-Type is wrong or missing, the server may reject or misinterpret the request, causing test failures.

Quick: Can you send variables inside raw body without any special syntax? Commit yes or no.

Common Belief: You can write variables directly in raw body text and Postman will replace them automatically without any syntax.

Reality: Variables must be wrapped in double curly braces like {{variable}} for Postman to substitute them.

Why it matters: Without correct syntax, variables remain as plain text, causing incorrect requests and test failures.

Quick: Does a malformed XML always cause a clear error response from the server? Commit yes or no.

Common Belief: If XML is malformed, the server will always return a clear error message.

Reality: Some servers silently ignore malformed parts or return generic errors, making debugging harder.

Why it matters: Assuming clear errors can lead to wasted time chasing wrong issues and missing the real problem.

Quick: Is raw body the best choice for all API request types? Commit yes or no.

Common Belief: Raw body is always the best way to send data in API requests.

Reality: Raw body is not ideal for multipart file uploads or simple form data, where form-data or urlencoded are better.

Why it matters: Using raw body in wrong scenarios can cause failed uploads or server errors.

Expert Zone

1

Raw body data encoding (UTF-8 vs others) can silently break APIs if mismatched with server expectations.

2

Some APIs require specific XML namespaces or headers that must be manually included in raw body, which automated tools miss.

3

Variable substitution in raw body can cause injection vulnerabilities if not sanitized properly in automated tests.

When NOT to use

Avoid raw body when sending multipart/form-data for file uploads or when APIs expect urlencoded form data. Use Postman's form-data or x-www-form-urlencoded options instead for those cases.

Production Patterns

In real-world API testing, raw body is used to test SOAP APIs with XML payloads, custom text protocols, or to simulate edge cases with malformed data. It is also combined with pre-request scripts to generate dynamic XML or text bodies for complex workflows.

Connections

HTTP Headers

builds-on

Understanding raw body is incomplete without knowing HTTP headers like Content-Type, which tell servers how to read the raw data.

API Automation Testing

builds-on

Mastering raw body enables writing flexible automated tests that send precise payloads, essential for robust API automation.

Data Serialization Formats

builds-on

Knowing raw body helps you appreciate how data formats like XML or JSON are serialized and transmitted over networks.

Common Pitfalls

#1 Sending raw XML without setting Content-Type header.

Wrong approach:

POST /api HTTP/1.1
Host: example.com

Test

Correct approach:

POST /api HTTP/1.1
Host: example.com
Content-Type: application/xml

Test

Root cause:

Forgetting to set Content-Type causes server to misinterpret the raw XML data.

#2 Writing variables in raw body without curly braces.

Wrong approach:

userId

Correct approach:

{{userId}}

Root cause:

Postman requires {{}} syntax to recognize and replace variables.

#3 Sending malformed XML in raw body.

Wrong approach:

Test

Correct approach:

Test

Root cause:

Missing closing tags cause XML parsing errors on the server.

Key Takeaways

Raw body in Postman lets you send exact data payloads without automatic formatting.

Always set the correct Content-Type header to match your raw body format for proper server processing.

You can send plain text, XML, JSON, or any custom format using raw body.

Using variables in raw body requires the {{variable}} syntax for dynamic testing.

Debugging raw body issues involves checking data correctness, headers, and server responses carefully.