The nine HTTP methods with the properties a retry policy depends on: which are safe, which are idempotent, and what each one means in practice.
9 methods
The matrix below is what decides whether a retry after a timeout is safe.
| Method | Safe | Idempotent | Cacheable | Request body | Response body |
|---|---|---|---|---|---|
| yes | yes | yes | discouraged | yes | |
| no | no | no | yes | yes | |
| no | yes | no | yes | yes | |
| no | no | no | yes | yes | |
| no | yes | no | discouraged | yes | |
| yes | yes | yes | no | no | |
| yes | yes | no | no | yes | |
| yes | yes | no | no | yes | |
| no | no | no | no | no |
Retrieve a representation of a resource.
Is it safe to retry?
Always safe to retry. A proxy, a browser or a crawler may repeat it at any time without asking.
What people get wrong
A GET with side effects breaks everything that assumes otherwise — prefetchers, caches, link checkers. The classic failure is a `/delete?id=5` link that a crawler follows.
Safe implies idempotent — a request that changes nothing has the same effect however many times it is made. The reverse does not hold.
HTTP Method Reference runs entirely on your device — nothing is uploaded.
You’re on the Free plan. Compare plans
Two words decide whether a failed request may be retried, and they are routinely confused. Safe means the request changes nothing. Idempotent means doing it twice leaves the same state as doing it once — so a retry after a timeout is harmless.
Safe implies idempotent; the reverse does not hold. PUT and DELETE are idempotent and not safe, which is exactly the combination that makes them retryable after a network failure where POST is not.
PATCH is the one people argue about, and the specification is right to call it not idempotent. A merge patch usually is; a patch containing an increment is not. The method cannot know which body it carries, so it assumes the worst — and an API that relies on PATCH being idempotent is relying on a property it does not have.
The practical consequence of all this is the retry policy. A client that retries a POST after a timeout can create two orders, which is why idempotency keys exist. A client that refuses to retry a PUT is being needlessly fragile.
The table also carries whether a request body is meaningful. A GET with a body is not forbidden and is widely unsupported — proxies drop it, caches ignore it, and several frameworks never read it.
Not in general. `{"name": "x"}` applied twice is harmless; `{"op": "increment"}` is not. The specification cannot know which you sent, so it assumes the worst — which means a client should not retry a PATCH blindly.
PUT replaces the whole resource, so fields absent from the body should end up unset. PATCH modifies part of it. An API whose PUT merges instead of replacing is a PATCH wearing the wrong name, and callers will be surprised.
Not forbidden, and widely unsupported. Proxies drop it, caches ignore it, several server frameworks never read it, and generated clients often cannot send one. If the server expects it, it works; otherwise the body silently disappears.
Because a request that changes nothing has the same effect however many times it is made — which is the definition of idempotent. That is why every safe method in the table is also marked idempotent.
Either is defensible, and it does not affect idempotency — the state after is identical. 204 is kinder to a retrying client; 404 is more literal. Pick one and document it.