Status code 202 means the server has accepted a request for processing but the action is not yet complete. The request may still be pending, and the result will be available later.
HTTP status codes classify responses from servers. Status code 202 falls under the 2xx success category, but it signals acceptance-not completion. This distinguishes it from 200 OK, which confirms immediate success.
When a client sends a request with a 202 response, it knows the server received the instruction and will handle it asynchronously. The client should not expect an immediate result. Instead, it must check back later using a polling mechanism or wait for a webhook notification.
The server processes the request in the background. For example, a user submits a form to generate a report. The server acknowledges the request with 202 Accepted and begins generating the file. The client receives a confirmation but must poll the server periodically to check if the report is ready.
This pattern reduces load on the client. Instead of waiting minutes for a long-running task, the client continues working while the server handles the work. Once done, the server returns a 200 OK with the file or a 404 if the task failed.
APIs often return 202 when initiating actions like sending emails, processing payments, or uploading large files. These operations take time and don't require immediate feedback. The 202 response allows the system to scale efficiently.
202 is not a single-purpose code. It applies to any request that requires background execution. Here are typical scenarios:
| Use Case | Why 202 Is Used | Example |
|---|---|---|
| Long-running jobs | Task takes seconds to minutes | Generating a PDF report from user data |
| Asynchronous workflows | Processing must happen in steps | Starting a video transcoding pipeline |
| Event-driven systems | Response depends on external triggers | Submitting a job to a queue for later execution |
Some APIs include a location header in the 202 response. This points to a resource where the client can check progress. For example:
HTTP/1.1 202 Accepted
Location: https://api.example.com/jobs/123/status
Content-Type: application/json
{"message": "Job queued for processing"}
When the client visits the URL in the Location header, it gets updates on the job's status. This avoids constant polling and improves efficiency.
Many developers mistake 202 for "success." It is not. A 202 response only confirms the server accepted the request. It does not guarantee the task will succeed. The final outcome may be 200 OK, 400 Bad Request, or 500 Internal Server Error.
Another error is assuming 202 implies immediate processing. The server may delay handling the request due to load or queue size. The client must not assume the task began instantly.
A lesser-known point: 202 is idempotent only if the server treats the request as a unique identifier. If multiple identical requests arrive, the server may create duplicate jobs unless it checks for existing ones. Idempotency is not guaranteed by the code itself-it depends on implementation.
For example, calling POST /jobs with the same JSON body twice may trigger two separate reports. The client must ensure uniqueness through identifiers or deduplication logic.
Consider a photo-sharing app that lets users upload images for AI tagging. The upload endpoint returns 202 Accepted upon receipt. The client sees:
POST /upload
Content-Type: image/jpeg
[binary data]
HTTP/1.1 202 Accepted
Location: https://api.photoshare.com/v1/tasks/789
Retry-After: 60
The client stores the task ID (789) and polls the status endpoint every 60 seconds. After 45 seconds, the server responds:
GET /v1/tasks/789
HTTP/1.1 202 Accepted
{"status": "processing", "progress": 65}
After 90 seconds, the server returns:
GET /v1/tasks/789
HTTP/1.1 200 OK
{"status": "completed", "tags": ["dog", "park", "sunny"]}
The client now displays the tags. The 202 response enabled a non-blocking workflow.
I once built a feature that processed 10,000 user records daily. Without 202, the frontend froze during uploads. After switching to 202 Accepted with polling, the app remained responsive. Users saw a loading spinner and were notified when processing finished. Response times dropped by 70% under peak load.
The W3C specifies that 202 "indicates that the request has been accepted for processing, but the processing has not been completed." W3C HTTP/1.1 Specification.
Google's REST API design guidelines recommend using 202 for long-running operations. They state: "Use 202 Accepted when the server cannot complete the request immediately." Google Cloud API Design.
Status code 202 is not a result-it's a handshake. It tells the client: "I've got your request. Work is underway. Check back later." It enables scalable, responsive systems. Use it when actions take time and immediate results aren't needed.