102 Processing

What is 102 Processing?

TL;DR: Server received your request and is working on it, but no response ready yet. Keep waiting for the final response.

A 102 Processing status code is an interim response indicating that the server has received and is processing the request, but no response is available yet. Think of it like a progress update during a lengthy download—it reassures you that something is happening, even though it’s not finished yet.

This code was introduced in WebDAV (Web Distributed Authoring and Versioning) to prevent clients from timing out during long-running operations like complex file operations or large file uploads.

When Does This Happen?

You’ll see a 102 Processing response in these common situations:

1. Large File Operations

Server processing a large file upload
Client uploads 5GB file → Server sends 102 while processing

2. Complex WebDAV Requests

PROPFIND operation on large directory structure
Client requests properties → Server sends 102 while traversing

3. Batch Operations

Server processing multiple file deletions
MKCOL with many nested collections → 102 during creation

4. Long-Running Searches

Searching through large document repositories
Client searches → Server sends 102 while indexing

5. Database-Heavy Operations

Complex queries taking more than timeout threshold
Client requests report → Server sends 102 while generating

Example Responses

WebDAV File Upload:

HTTP/1.1 102 Processing
Status: Processing large file upload

(Connection remains open, server continues processing)
```text

**Complex PROPFIND Operation:**

```http
HTTP/1.1 102 Processing
Status-URI: https://webdav.example.com/status/req-12345
Progress: Scanning directory tree

(Followed by final response when complete)

Batch File Operation:

HTTP/1.1 102 Processing
Content-Type: text/plain

Processing batch operation: 45% complete
Estimated time remaining: 30 seconds
```text

## Real-World Example

Imagine you're using a WebDAV client to upload a large video file to a server:

**Client Upload Request:**

```http
PUT /videos/presentation.mp4 HTTP/1.1
Host: webdav.example.com
Content-Length: 5368709120
Content-Type: video/mp4
Expect: 100-continue

[5GB video data...]

102 Processing Response:

HTTP/1.1 102 Processing
Content-Type: text/plain
Date: Sat, 18 Jan 2026 10:30:00 GMT

Processing upload: Validating file integrity
Current progress: 2.5GB / 5GB received
Estimated completion: 45 seconds
```text

**Final Success Response:**

```http
HTTP/1.1 201 Created
Location: https://webdav.example.com/videos/presentation.mp4
ETag: "abc123def456"
Content-Type: text/plain

File uploaded successfully

102 vs Other Informational Codes

Code	Meaning	Purpose	Connection State
102	Processing	Long operations update	Kept alive during processing
100	Continue	Send request body	Kept alive for body transmission
103	Early Hints	Send early headers	Kept alive for final response
200	OK	Success (final)	Closes after response

Important Characteristics

Keeps Connection Alive:

HTTP/1.1 102 Processing
Connection: keep-alive  ← Prevents timeout
Status: Processing request...
```text

**Interim Response:**

```text
- 102 is NOT the final response
- Server MUST send a final status code (2xx, 4xx, 5xx)
- Client should continue waiting for final response
```text

**Multiple 102 Responses:**

```http
HTTP/1.1 102 Processing
Status: Starting operation...

HTTP/1.1 102 Processing
Status: 50% complete...

HTTP/1.1 102 Processing
Status: 90% complete...

HTTP/1.1 200 OK
Content-Type: application/json
{"status": "complete"}

Common Mistakes

❌ Sending 102 for quick operations

HTTP/1.1 102 Processing  ← Unnecessary for operations < 20 seconds
Content-Type: text/plain

Processing simple GET request...
```text

**❌ Never sending final response**

```http
HTTP/1.1 102 Processing
Status: Processing...
(Connection hangs, no final response sent)  ← Client will timeout

❌ Using 102 outside WebDAV context

HTTP/1.1 102 Processing  ← Not widely supported in regular HTTP
(Most browsers ignore or don't handle this properly)
```text

**✅ Correct usage**

```http
HTTP/1.1 102 Processing
Status: Processing WebDAV PROPFIND operation
Progress: 30%

(Later...)
HTTP/1.1 207 Multi-Status  ← Final response

Best Practices

Send 102 Only for Long Operations:

If operation takes > 20 seconds:
  HTTP/1.1 102 Processing
  Status: Operation in progress
```text

**Provide Meaningful Status Updates:**

```http
HTTP/1.1 102 Processing
Content-Type: text/plain

Processing batch file operation
Files processed: 150 / 500
Current file: document_0150.pdf
Estimated time remaining: 2 minutes

Always Send Final Response:

// Pseudo-code pattern
sendInterimResponse(102, 'Processing request...')
performLongOperation()
sendFinalResponse(200, result) // Always send final response
```text

**Set Appropriate Timeouts:**

```http
HTTP/1.1 102 Processing
Keep-Alive: timeout=300, max=1000
Status: Long operation in progress

Implementation Examples

Node.js with Express:

app.put('/webdav/upload', async (req, res) => {
  // Send interim 102 response
  res.writeHead(102, { 'Content-Type': 'text/plain' })
  res.write('Processing upload...\n')

  // Process the upload
  await processLargeUpload(req, (progress) => {
    // Send additional 102 updates
    res.write(`Progress: ${progress}%\n`)
  })

  // Send final response
  res.writeHead(201, { Location: '/webdav/upload/file.dat' })
  res.end('Upload complete')
})
```text

**Apache WebDAV Configuration:**

```apache
<Location /webdav>
  DAV On
  # Enable interim responses for long operations
  DavMinTimeout 300
  DavProcessingDelay 20
</Location>

Python with WebDAV:

from http.server import BaseHTTPRequestHandler

class WebDAVHandler(BaseHTTPRequestHandler):
    def do_PUT(self):
        # Send 102 Processing
        self.send_response(102)
        self.send_header('Content-Type', 'text/plain')
        self.end_headers()
        self.wfile.write(b'Processing upload...\n')

        # Process upload
        content_length = int(self.headers['Content-Length'])
        file_data = self.rfile.read(content_length)

        # Send final response
        self.send_response(201)
        self.send_header('Location', '/uploaded/file.dat')
        self.end_headers()
```text

## Browser and Client Support

**Limited Support:**

- 102 is primarily a WebDAV feature
- Most modern browsers ignore 102 responses
- Specialized WebDAV clients handle it properly
- HTTP/2 and HTTP/3 have better alternatives

**Better Alternatives for Modern Apps:**

```text
For long operations, consider:
- WebSockets for real-time updates
- Server-Sent Events (SSE) for progress streaming
- 202 Accepted with status endpoint polling

Try It Yourself

Visit our request builder and simulate a 102 response:

1. Set method to PUT
2. Set path to /webdav/upload
3. Add header Content-Type: application/octet-stream
4. Click Send request
5. Watch for interim 102 responses during processing

Related Status Codes

• 100 Continue - Request to proceed with body transmission
• 103 Early Hints - Send early response headers for preloading
• 202 Accepted - Request accepted, processing asynchronously
• 201 Created - Resource successfully created