# 102 Processing > The server has accepted the request and is processing it, but no response is available yet. Learn about this WebDAV status code for long-running operations. Source: https://howhttpworks.com/status-codes/102 Last reviewed: 2026-10-04 > **TL;DR:** Server received your request and is working on it, but no response ready yet. Keep waiting for the final response. ## What is 102 Processing? 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** ```text Server processing a large file upload Client uploads 5GB file → Server sends 102 while processing ``` **2. Complex WebDAV Requests** ```text PROPFIND operation on large directory structure Client requests properties → Server sends 102 while traversing ``` **3. Batch Operations** ```text Server processing multiple file deletions MKCOL with many nested collections → 102 during creation ``` **4. Long-Running Searches** ```text Searching through large document repositories Client searches → Server sends 102 while indexing ``` **5. Database-Heavy Operations** ```text Complex queries taking more than timeout threshold Client requests report → Server sends 102 while generating ``` ## Example Responses **WebDAV File Upload:** ```http HTTP/1.1 102 Processing Status: Processing large file upload (Connection remains open, server continues processing) ``` **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 HTTP/1.1 102 Processing Content-Type: text/plain Processing batch operation: 45% complete Estimated time remaining: 30 seconds ``` ## 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 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 ``` **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 HTTP/1.1 102 Processing Connection: keep-alive ← Prevents timeout Status: Processing request... ``` **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 ``` **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 HTTP/1.1 102 Processing ← Unnecessary for operations < 20 seconds Content-Type: text/plain Processing simple GET request... ``` **❌ 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 HTTP/1.1 102 Processing ← Not widely supported in regular HTTP (Most browsers ignore or don't handle this properly) ``` **✅ Correct usage** ```http HTTP/1.1 102 Processing Status: Processing WebDAV PROPFIND operation Progress: 30% (Later...) HTTP/1.1 207 Multi-Status ← Final response ``` ## Getting 102 Processing right **Send 102 Only for Long Operations:** ```http If operation takes > 20 seconds: HTTP/1.1 102 Processing Status: Operation in progress ``` **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:** ```javascript // Pseudo-code pattern sendInterimResponse(102, 'Processing request...') performLongOperation() sendFinalResponse(200, result) // Always send final response ``` **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:** ```javascript 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') }) ``` **Apache WebDAV Configuration:** ```apache DAV On # Enable interim responses for long operations DavMinTimeout 300 DavProcessingDelay 20 ``` **Python with WebDAV:** ```python 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() ``` ## 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](https://howhttpworks.com/tools/playground) 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 ## Try it with curl `102 Processing` is a WebDAV-era interim response that most servers never send, so you will not be able to trigger it on demand. If a server does send one, `curl -v` prints it as a `< HTTP/1.1 102 Processing` block before the final status line. ```bash curl -v -X PROPFIND -H 'Depth: infinity' https://dav.example.com/large-collection/ ``` ## Related Status Codes - [100 Continue](https://howhttpworks.com/status-codes/100) - Request to proceed with body transmission - [103 Early Hints](https://howhttpworks.com/status-codes/103) - Send early response headers for preloading - [202 Accepted](https://howhttpworks.com/status-codes/202) - Request accepted, processing asynchronously - [201 Created](https://howhttpworks.com/status-codes/201) - Resource successfully created