Skip to content
4244xx · Client errorThe client seems to have erred. RFC 9110 §15.5

HTTP 424 Failed Dependency: what it means and how to fix it

Meaning

HTTP 424 Failed Dependency means a request failed because another action it relied on failed. Where it comes from, a local repro and fixes.

HTTP 424 means the server could not carry out your request because it depended on another action, and that other action failed. The reason phrase is “Failed Dependency”. It is not in RFC 9110: it comes from WebDAV, RFC 4918, section 11.4, and the IANA registry still cites that RFC for it. A 424 identifies the dependency failure; find that first.

Inside a WebDAV 207 Multi-Status body, it marks the parts of a request that were abandoned because another part failed. As a top-level status, some APIs use it to say “a service I depend on failed”. Amazon SageMaker’s InvokeEndpoint returns ModelError with HTTP 424 when the customer’s model container answers with a 4xx or 5xx, and puts the container’s status in OriginalStatusCode. Amazon Bedrock’s InvokeModel returns ModelErrorException with 424 and an originalStatusCode field.

Reproduce it locally

This Python server runs two services. The back one fails with a retryable 503. The front one calls it and reports the failure as 424, the way a gateway in front of a model or a database might:

# gateway.py: a front service on :8425 that depends on a back service on :8426
import json, threading, urllib.request, urllib.error
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

class Backend(BaseHTTPRequestHandler):
    def do_POST(self):
        self.send_response(503)
        self.send_header("Retry-After", "30")
        self.send_header("Content-Length", "0")
        self.end_headers()

class Front(BaseHTTPRequestHandler):
    def do_POST(self):
        try:
            req = urllib.request.Request("http://127.0.0.1:8426/", data=b"{}", method="POST")
            urllib.request.urlopen(req, timeout=5)
            code, out = 200, {"ok": True}
        except urllib.error.HTTPError as e:
            code, out = 424, {"error": "dependency failed", "originalStatusCode": e.code}
        body = json.dumps(out).encode() + b"\n"
        self.send_response(code)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

threading.Thread(target=ThreadingHTTPServer(("127.0.0.1", 8426), Backend).serve_forever, daemon=True).start()
ThreadingHTTPServer(("127.0.0.1", 8425), Front).serve_forever()

Start it with python3 gateway.py. Real output from Python 3.15.0 and curl 8.7.1, Date header removed:

$ curl -si -X POST --data '{"q":"price"}' http://127.0.0.1:8425/ | grep -v '^Date:'
HTTP/1.0 424 Failed Dependency
Server: BaseHTTP Python/3.15.0
Content-Type: application/json
Content-Length: 58

{"error": "dependency failed", "originalStatusCode": 503}
$ curl -si -X POST --data '{}' http://127.0.0.1:8426/ | grep -v '^Date:'
HTTP/1.0 503 Service Unavailable
Server: BaseHTTP Python/3.15.0
Retry-After: 30
Content-Length: 0

The 424 hid the 503, and the fresh front response dropped the back service’s Retry-After: 30. A client that sees only the outer 4xx may give up on a request that would work later or retry one that never will. Read the wrapped status before deciding.

The original WebDAV case, on Apache mod_dav

PROPPATCH sets or removes properties on a resource, and RFC 4918 makes it atomic: every instruction is applied or none is. When one property change fails, the others are reported as 424 (section 9.2.1). Here is a request that sets one ordinary property and tries to overwrite DAV:getetag, which the server computes itself, sent to Apache 2.4.67 with mod_dav on macOS:

$ cat patch.xml
<?xml version="1.0" encoding="utf-8"?>
<D:propertyupdate xmlns:D="DAV:" xmlns:Z="urn:example:props">
  <D:set><D:prop><Z:owner>scraper-team</Z:owner></D:prop></D:set>
  <D:set><D:prop><D:getetag>"forced"</D:getetag></D:prop></D:set>
</D:propertyupdate>
$ curl -s -X PROPPATCH -H 'Content-Type: application/xml' --data-binary @patch.xml -w '\nHTTP %{http_code}\n' http://127.0.0.1:8424/q3.txt
<?xml version="1.0" encoding="utf-8"?>
<D:multistatus xmlns:D="DAV:" xmlns:ns1="urn:example:props" xmlns:ns0="DAV:">
<D:response>
<D:href>/q3.txt</D:href>
<D:propstat>
<D:prop><ns1:owner/>
</D:prop>
<D:status>HTTP/1.1 424 (status)</D:status>
<D:responsedescription>
Attempted DAV:set operation could not be completed due to other errors.</D:responsedescription>
</D:propstat>
<D:propstat>
<D:prop><ns0:getetag/>
</D:prop>
<D:status>HTTP/1.1 409 (status)</D:status>
<D:responsedescription>
Property is read-only.</D:responsedescription>
</D:propstat>
</D:response>
</D:multistatus>

HTTP 207
$ curl -s -X PROPFIND -H 'Depth: 0' -H 'Content-Type: application/xml' --data-binary @find.xml http://127.0.0.1:8424/q3.txt | grep '<D:status>'
<D:status>HTTP/1.1 404 Not Found</D:status>
$ curl -s -X PROPPATCH -H 'Content-Type: application/xml' --data-binary @patch-ok.xml http://127.0.0.1:8424/q3.txt | grep '<D:status>'
<D:status>HTTP/1.1 200 OK</D:status>

The overall status is 207, and the 424 sits inside the body next to the change that actually failed. The PROPFIND, whose find.xml asks only for owner, confirms nothing was stored: the property is still 404. Sent alone, in patch-ok.xml, which is patch.xml without the getetag line, the same change returns 200.

Two parser details matter. Apache writes the inner status as HTTP/1.1 424 (status), with no reason phrase, so matching “Failed Dependency” misses it. It answered the read-only property with 409, though RFC 4918 suggests 403 with a cannot-modify-protected-property condition; match the number.

A forward proxy reports its own upstream failures as 502 Bad Gateway or 504 Gateway Timeout (RFC 9110, sections 15.6.3 and 15.6.5), not 424. A 424 seen through a proxy was produced by the application or API behind it, so changing exits will not change it.

When a scraper, proxy or agent hits it

Find the dependency first. In a WebDAV response, scan every propstat for a status that is not 424; that is the one to fix or drop before resending. In an API response, read the body for the original status code and treat the request as if it had returned that code. For a model endpoint called from an agent or a RAG pipeline, that means backing off on a wrapped 429 or 5xx and fixing the input on a wrapped 4xx.

Check your retry rules too. Scrapy’s default RETRY_HTTP_CODES is [500, 502, 503, 504, 522, 524, 408, 429], so a 424 wrapping a 503 is dropped rather than retried unless you handle it. If you run the gateway yourself, return the dependency’s status and its Retry-After in the response, so the client does not have to guess.

Where the 424 appears The real failure What to change
Inside a 207 reply to PROPPATCH Another property change in the same request failed, such as 403, 409 or 507 Find the non-424 propstat, fix or remove that property, resend the rest
SageMaker InvokeEndpoint The model container returned a 4xx or 5xx Branch on OriginalStatusCode and read the container’s log stream
Bedrock InvokeModel An error while the model processed the request Branch on originalStatusCode; retry only transient codes
Your own gateway or microservice A downstream call failed Pass through the original status and Retry-After, or answer 502 or 503 where that is the truth
A scraper’s retry log A wrapped transient error treated as final Parse the wrapped code and add it to your retry decision

More on handling model calls from crawlers and agents is in proxies for AI agents that browse. For the codes a target uses to refuse or throttle you, see 403 vs 407 vs 429, and for pacing the retries, exponential backoff.

Frequently asked questions

What does HTTP 424 Failed Dependency mean?
The server could not complete this request because another action it depended on failed. In a WebDAV 207 Multi-Status response, inspect the other propstat entries to find that earlier failure. In an API response, read the body for the wrapped status or dependency name.
Is HTTP 424 a WebDAV-only status?
It was defined by WebDAV in RFC 4918, where it is used for a failed property operation. APIs also use the same status for a failed downstream service, but those meanings are application contracts rather than a new HTTP standard definition.
Should a client retry a 424?
Not automatically. Find the dependency's status first. Retry only when that underlying status is transient, such as a rate limit or temporary upstream failure, and preserve its Retry-After value when the server provides one.
How do I debug a 424 from a model or proxy gateway?
Read the response body for the original status code, request ID and dependency name, then test that dependency directly if you control it. A wrapped 4xx usually needs an input or permission fix; a wrapped 5xx needs an upstream health check or bounded retry.

Sources

  1. RFC 4918 section 11.4: 424 Failed Dependency
  2. RFC 4918 section 9.2.1: WebDAV PROPPATCH and 207 Multi-Status
  3. RFC 9110 section 15.6.3: 502 Bad Gateway and gateway failure semantics
  4. Amazon SageMaker InvokeEndpoint API reference
  5. Amazon Bedrock InvokeModel API reference

All terms, A to Z