Request Body

Simple Object

POST /api/login
Content-Type: application/json

{
  "email": "user@example.com",
  "password": "securePassword123"
}

Nested Object

POST /api/orders
Content-Type: application/json

{
  "customer": {
    "name": "Nguyễn Văn A",
    "email": "vana@example.com",
    "phone": "0123456789"
  },
  "items": [
    {
      "product_id": 101,
      "quantity": 2,
      "price": 500000
    },
    {
      "product_id": 202,
      "quantity": 1,
      "price": 1000000
    }
  ],
  "shipping_address": {
    "street": "123 Main St",
    "city": "Hà Nội",
    "district": "Ba Đình",
    "country": "Vietnam"
  },
  "payment_method": "credit_card",
  "notes": "Giao hàng giờ hành chính"
}

Playwright - JSON Body

import { test, expect } from '@playwright/test';

test('POST JSON - Simple', async ({ request }) => {
  const response = await request.post('https://api.example.com/login', {
    data: {
      email: 'user@example.com',
      password: 'password123'
    }
    // Playwright tự động set Content-Type: application/json
  });

  expect(response.status()).toBe(200);

  const result = await response.json();
  expect(result).toHaveProperty('token');
});

test('POST JSON - Nested Objects', async ({ request }) => {
  const response = await request.post('https://api.example.com/orders', {
    data: {
      customer: {
        name: 'Nguyễn Văn A',
        email: 'vana@example.com',
        phone: '0123456789'
      },
      items: [
        { product_id: 101, quantity: 2, price: 500000 },
        { product_id: 202, quantity: 1, price: 1000000 }
      ],
      shipping_address: {
        street: '123 Main St',
        city: 'Hà Nội',
        country: 'Vietnam'
      },
      payment_method: 'credit_card'
    }
  });

  expect(response.status()).toBe(201);

  const order = await response.json();
  expect(order).toHaveProperty('id');
  expect(order).toHaveProperty('total');
  expect(order.items).toHaveLength(2);
});

PHP - Đọc JSON Body

<?php
// Đọc JSON từ request body
$json = file_get_contents('php://input');
$data = json_decode($json, true);

// Validate
if (json_last_error() !== JSON_ERROR_NONE) {
    http_response_code(400);
    echo json_encode(['error' => 'Invalid JSON']);
    exit;
}

// Access data
$email = $data['email'] ?? null;
$password = $data['password'] ?? null;

if (!$email || !$password) {
    http_response_code(400);
    echo json_encode(['error' => 'Email and password required']);
    exit;
}

// Process login...
$result = ['token' => 'abc123xyz', 'user_id' => 1];

// Send JSON response
header('Content-Type: application/json');
echo json_encode($result);
?>

Format

POST /api/login
Content-Type: application/x-www-form-urlencoded

email=user%40example.com&password=password123&remember=true

Giống query string nhưng ở trong body!

Playwright - Form Urlencoded

import { test, expect } from '@playwright/test';

test('POST form-urlencoded', async ({ request }) => {
  const response = await request.post('https://api.example.com/login', {
    form: {  // ← Dùng 'form' thay vì 'data'
      email: 'user@example.com',
      password: 'password123',
      remember: 'true'
    }
  });

  expect(response.status()).toBe(200);
});

// Hoặc set header manually
test('POST form-urlencoded (manual)', async ({ request }) => {
  const params = new URLSearchParams({
    email: 'user@example.com',
    password: 'password123',
    remember: 'true'
  });

  const response = await request.post('https://api.example.com/login', {
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded'
    },
    body: params.toString()
  });

  expect(response.status()).toBe(200);
});

PHP - Đọc Form Urlencoded

<?php
// PHP tự động parse form-urlencoded vào $_POST
$email = $_POST['email'] ?? null;
$password = $_POST['password'] ?? null;
$remember = $_POST['remember'] ?? false;

// Hoặc đọc raw
$body = file_get_contents('php://input');
parse_str($body, $data);

$email = $data['email'] ?? null;
$password = $data['password'] ?? null;
?>

Format

POST /api/upload
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW

------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="title"

My Document
------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="description"

Document description here
------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="file"; filename="document.pdf"
Content-Type: application/pdf

[binary PDF data here]
------WebKitFormBoundary7MA4YWxkTrZu0gW--

Playwright - File Upload

import { test, expect } from '@playwright/test';
import fs from 'fs';
import path from 'path';

test('Upload file with form data', async ({ request }) => {
  // Đọc file
  const filePath = path.join(__dirname, 'files', 'document.pdf');
  const fileBuffer = fs.readFileSync(filePath);

  const response = await request.post('https://api.example.com/upload', {
    multipart: {
      title: 'My Document',
      description: 'Important document',
      category: 'reports',
      file: {
        name: 'document.pdf',
        mimeType: 'application/pdf',
        buffer: fileBuffer
      }
    }
  });

  expect(response.status()).toBe(201);

  const result = await response.json();
  expect(result).toHaveProperty('file_id');
  expect(result).toHaveProperty('url');
});

test('Upload multiple files', async ({ request }) => {
  const file1 = fs.readFileSync('image1.jpg');
  const file2 = fs.readFileSync('image2.jpg');

  const response = await request.post('https://api.example.com/upload-multiple', {
    multipart: {
      title: 'Photo Album',
      files: [
        {
          name: 'image1.jpg',
          mimeType: 'image/jpeg',
          buffer: file1
        },
        {
          name: 'image2.jpg',
          mimeType: 'image/jpeg',
          buffer: file2
        }
      ]
    }
  });

  expect(response.status()).toBe(201);
});

test('Upload image from URL', async ({ request }) => {
  // Fetch image từ URL
  const imageResponse = await request.get('https://via.placeholder.com/150');
  const imageBuffer = await imageResponse.body();

  const uploadResponse = await request.post('https://api.example.com/upload', {
    multipart: {
      name: 'avatar',
      file: {
        name: 'avatar.png',
        mimeType: 'image/png',
        buffer: imageBuffer
      }
    }
  });

  expect(uploadResponse.status()).toBe(201);
});

PHP - Handle File Upload

<?php
// Check if file uploaded
if (!isset($_FILES['file']) || $_FILES['file']['error'] !== UPLOAD_ERR_OK) {
    http_response_code(400);
    echo json_encode(['error' => 'No file uploaded']);
    exit;
}

$file = $_FILES['file'];
$title = $_POST['title'] ?? 'Untitled';
$description = $_POST['description'] ?? '';

// Validate file
$allowedTypes = ['image/jpeg', 'image/png', 'application/pdf'];
if (!in_array($file['type'], $allowedTypes)) {
    http_response_code(400);
    echo json_encode(['error' => 'Invalid file type']);
    exit;
}

// Validate size (max 5MB)
$maxSize = 5 * 1024 * 1024;
if ($file['size'] > $maxSize) {
    http_response_code(400);
    echo json_encode(['error' => 'File too large']);
    exit;
}

// Generate unique filename
$ext = pathinfo($file['name'], PATHINFO_EXTENSION);
$newFilename = uniqid() . '.' . $ext;
$uploadPath = '/var/www/uploads/' . $newFilename;

// Move uploaded file
if (!move_uploaded_file($file['tmp_name'], $uploadPath)) {
    http_response_code(500);
    echo json_encode(['error' => 'Failed to save file']);
    exit;
}

// Save to database
$fileId = saveToDatabase($title, $description, $newFilename, $file['size']);

// Return response
header('Content-Type: application/json');
echo json_encode([
    'success' => true,
    'file_id' => $fileId,
    'url' => 'https://cdn.example.com/uploads/' . $newFilename,
    'size' => $file['size']
]);
?>

XML Format

POST /api/users
Content-Type: application/xml

<?xml version="1.0" encoding="UTF-8"?>
<user>
  <name>Nguyễn Văn A</name>
  <email>vana@example.com</email>
  <age>25</age>
  <address>
    <city>Hà Nội</city>
    <country>Vietnam</country>
  </address>
</user>

Playwright - XML Body

import { test, expect } from '@playwright/test';

test('POST XML data', async ({ request }) => {
  const xmlData = `<?xml version="1.0" encoding="UTF-8"?>
<user>
  <name>Nguyễn Văn A</name>
  <email>vana@example.com</email>
  <age>25</age>
</user>`;

  const response = await request.post('https://api.example.com/users', {
    headers: {
      'Content-Type': 'application/xml'
    },
    data: xmlData
  });

  expect(response.status()).toBe(201);

  // Parse XML response
  const responseText = await response.text();
  expect(responseText).toContain('<user>');
});

PHP - Parse XML

<?php
$xml = file_get_contents('php://input');

// Parse XML
$doc = simplexml_load_string($xml);

if ($doc === false) {
    http_response_code(400);
    echo '<error>Invalid XML</error>';
    exit;
}

// Access data
$name = (string)$doc->name;
$email = (string)$doc->email;
$age = (int)$doc->age;

// Process...

// Send XML response
header('Content-Type: application/xml');
echo '<?xml version="1.0"?>';
echo '<response>';
echo '  <success>true</success>';
echo '  <user_id>123</user_id>';
echo '</response>';
?>

Playwright Examples

import { test, expect } from '@playwright/test';

// Text/plain
test('POST plain text', async ({ request }) => {
  const response = await request.post('https://api.example.com/notes', {
    headers: {
      'Content-Type': 'text/plain'
    },
    data: 'This is my note content.\nMultiple lines supported.'
  });

  expect(response.status()).toBe(201);
});

// Binary data
test('POST binary data', async ({ request }) => {
  const buffer = Buffer.from([0x89, 0x50, 0x4E, 0x47]); // PNG header

  const response = await request.post('https://api.example.com/upload', {
    headers: {
      'Content-Type': 'application/octet-stream'
    },
    data: buffer
  });

  expect(response.status()).toBe(201);
});