gRPC Status Codes Reference
All 17 gRPC status codes with meaning, retry guidance, common causes and per-language constants — searchable instantly on this device.
A code like 14, a name like UNAVAILABLE, or a pasted constant like codes.Unavailable. Nothing you type leaves this page.
All 17 status codes shown
The status code table
Every row is transcribed from grpc/grpc doc/statuscodes.md and google.rpc.Code (code.proto); the HTTP column is grpc-gateway's REST mapping, cross-checked against two independent transcriptions. On the wire, a gRPC response answers HTTP/2 :status 200 even on error — the real status rides the grpc-status trailer.
| Code | Name | Meaning | Retry | HTTP (grpc-gateway) |
|---|---|---|---|---|
| 0 | OK | The operation completed successfully. It is a real status code — success travels on the wire exactly the way errors do. | No | 200 |
| 1 | CANCELLED | The operation was cancelled, typically by the caller — the client hung up, not the server. | No | 499 |
| 2 | UNKNOWN | An unknown error — classically an error relayed from another address space, or a server exception that carried no gRPC status of its own. | Sometimes — see note | 500 |
| 3 | INVALID_ARGUMENT | The client specified an invalid argument — one that is wrong regardless of the state of the system, which is exactly what separates it from FAILED_PRECONDITION. | No | 400 |
| 4 | DEADLINE_EXCEEDED | The deadline expired before the operation could complete. The server may still have finished the work successfully after the client stopped waiting. | Sometimes — see note | 504 |
| 5 | NOT_FOUND | A requested entity — a record, a file, a configured route — was not found. | No | 404 |
| 6 | ALREADY_EXISTS | The entity a client attempted to create already exists. | No | 409 |
| 7 | PERMISSION_DENIED | The caller is known but does not have permission for this operation — where UNAUTHENTICATED means the caller was never validly identified at all. | No | 403 |
| 8 | RESOURCE_EXHAUSTED | Some resource has been exhausted — a per-user quota, a rate limit, or a hard limit such as a maximum message size. | Sometimes — see note | 429 |
| 9 | FAILED_PRECONDITION | The operation was rejected because the system is not in a state it requires — deleting a directory that is not empty is the doc's own example. | No | 400 |
| 10 | ABORTED | The operation was aborted, typically over a concurrency issue such as a transaction abort or a lost optimistic lock. | Sometimes — see note | 409 |
| 11 | OUT_OF_RANGE | The operation was attempted past the valid range — like reading beyond end-of-file. Unlike INVALID_ARGUMENT, the same request may become valid as state changes. | No | 400 |
| 12 | UNIMPLEMENTED | The operation is not implemented, or not supported or enabled, in this service. | No | 501 |
| 13 | INTERNAL | An internal error: some invariant the underlying system expected has been broken. The docs reserve it for serious errors. | Sometimes — see note | 500 |
| 14 | UNAVAILABLE | The service is currently unavailable — most likely a transient condition around connectivity, load balancing or a restarting backend. The canonical retry-with-backoff code. | Retry with backoff | 503 |
| 15 | DATA_LOSS | Unrecoverable data loss or corruption was detected. | No | 500 |
| 16 | UNAUTHENTICATED | The request does not carry valid authentication credentials — who you are; PERMISSION_DENIED is about what you may do. | No | 401 |
Every code in detail
Each section below is its own anchor — #code-14 is a direct link to UNAVAILABLE. The search field above filters the table rows and these sections together.
0 OK
The operation completed successfully. It is a real status code — success travels on the wire exactly the way errors do.
- Retry guidance
- No — Nothing failed, so there is nothing to retry.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 200.
Common causes
- The call completed and the server committed its result.
- A streaming call ends with OK when the server closes the stream cleanly.
Per-language constants
- Go
codes.OK- Java
Status.Code.OK- Python
grpc.StatusCode.OK- Node.js
status.OK- C#
StatusCode.OK
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
1 CANCELLED
The operation was cancelled, typically by the caller — the client hung up, not the server.
- Retry guidance
- No — The caller cancelled the call on purpose; repeat it only if the caller still wants the result.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 499.
Common causes
- The client cancelled the RPC or tore down its context mid-call.
- A caller's own timeout machinery abandoned the call before the server answered.
Per-language constants
- Go
codes.Canceled- Java
Status.Code.CANCELLED- Python
grpc.StatusCode.CANCELLED- Node.js
status.CANCELLED- C#
StatusCode.Cancelled
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
2 UNKNOWN
An unknown error — classically an error relayed from another address space, or a server exception that carried no gRPC status of its own.
- Retry guidance
- Sometimes — see note — The cause is unknown by definition — retry only work that is safe to repeat, and read the server logs before trusting a second attempt.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 500.
Common causes
- A server-side exception escaped the handler without a gRPC status attached.
- An error from another system could not be translated into a canonical code.
Per-language constants
- Go
codes.Unknown- Java
Status.Code.UNKNOWN- Python
grpc.StatusCode.UNKNOWN- Node.js
status.UNKNOWN- C#
StatusCode.Unknown
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
3 INVALID_ARGUMENT
The client specified an invalid argument — one that is wrong regardless of the state of the system, which is exactly what separates it from FAILED_PRECONDITION.
- Retry guidance
- No — The request itself is malformed; it will fail the same way until the argument is fixed.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 400.
Common causes
- A field failed validation — a malformed resource name, a negative count, an unknown enum value.
- The request would be rejected in any system state, not just the current one.
Per-language constants
- Go
codes.InvalidArgument- Java
Status.Code.INVALID_ARGUMENT- Python
grpc.StatusCode.INVALID_ARGUMENT- Node.js
status.INVALID_ARGUMENT- C#
StatusCode.InvalidArgument
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
4 DEADLINE_EXCEEDED
The deadline expired before the operation could complete. The server may still have finished the work successfully after the client stopped waiting.
- Retry guidance
- Sometimes — see note — The work may have completed after the deadline passed — retry only idempotent operations, and give the retry a longer deadline.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 504.
Common causes
- The deadline the client attached to the call expired before the server finished.
- A slow downstream dependency consumed the whole deadline budget as it propagated along the call chain.
Per-language constants
- Go
codes.DeadlineExceeded- Java
Status.Code.DEADLINE_EXCEEDED- Python
grpc.StatusCode.DEADLINE_EXCEEDED- Node.js
status.DEADLINE_EXCEEDED- C#
StatusCode.DeadlineExceeded
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
5 NOT_FOUND
A requested entity — a record, a file, a configured route — was not found.
- Retry guidance
- No — Retrying will not create the missing resource — check the name, or create it first.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 404.
Common causes
- The named resource does not exist: a wrong id, or a row that was already deleted.
- A gradual rollout or an allowlist is hiding the endpoint from this caller — the docs sanction NOT_FOUND for that case.
Per-language constants
- Go
codes.NotFound- Java
Status.Code.NOT_FOUND- Python
grpc.StatusCode.NOT_FOUND- Node.js
status.NOT_FOUND- C#
StatusCode.NotFound
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
6 ALREADY_EXISTS
The entity a client attempted to create already exists.
- Retry guidance
- No — A retried create hits the same existing row again; read the entity instead of recreating it.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 409.
Common causes
- A create call named an entity that is already there.
- A retried create landed twice because the first attempt actually succeeded.
Per-language constants
- Go
codes.AlreadyExists- Java
Status.Code.ALREADY_EXISTS- Python
grpc.StatusCode.ALREADY_EXISTS- Node.js
status.ALREADY_EXISTS- C#
StatusCode.AlreadyExists
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
7 PERMISSION_DENIED
The caller is known but does not have permission for this operation — where UNAUTHENTICATED means the caller was never validly identified at all.
- Retry guidance
- No — Fix the caller's authorisation first — and note the docs reserve quota failures for RESOURCE_EXHAUSTED, not this code.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 403.
Common causes
- The authenticated caller lacks the grant for this method or resource.
- An IAM policy, ACL or token scope is missing the required permission.
Per-language constants
- Go
codes.PermissionDenied- Java
Status.Code.PERMISSION_DENIED- Python
grpc.StatusCode.PERMISSION_DENIED- Node.js
status.PERMISSION_DENIED- C#
StatusCode.PermissionDenied
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
8 RESOURCE_EXHAUSTED
Some resource has been exhausted — a per-user quota, a rate limit, or a hard limit such as a maximum message size.
- Retry guidance
- Sometimes — see note — A quota or rate limit is in the way — back off before any retry, or the retries feed the very exhaustion that caused them.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 429.
Common causes
- A per-user quota or a rate limit was hit.
- A message exceeded the configured maximum size — oversize payloads surface as this code.
- The server ran out of a real resource such as memory or connection slots.
Per-language constants
- Go
codes.ResourceExhausted- Java
Status.Code.RESOURCE_EXHAUSTED- Python
grpc.StatusCode.RESOURCE_EXHAUSTED- Node.js
status.RESOURCE_EXHAUSTED- C#
StatusCode.ResourceExhausted
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
9 FAILED_PRECONDITION
The operation was rejected because the system is not in a state it requires — deleting a directory that is not empty is the doc's own example.
- Retry guidance
- No — The docs are explicit: do not retry until the system state has been explicitly fixed.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 400.
Common causes
- The system is not in the state the operation needs, and only an explicit fix will change that.
- A workflow step ran out of order — the thing this call depends on has not happened yet.
Per-language constants
- Go
codes.FailedPrecondition- Java
Status.Code.FAILED_PRECONDITION- Python
grpc.StatusCode.FAILED_PRECONDITION- Node.js
status.FAILED_PRECONDITION- C#
StatusCode.FailedPrecondition
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
10 ABORTED
The operation was aborted, typically over a concurrency issue such as a transaction abort or a lost optimistic lock.
- Retry guidance
- Sometimes — see note — Retry at a higher level of abstraction — rerun the whole transaction, not just the failed call inside it.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 409.
Common causes
- A transaction aborted after a sequencer or version check failed.
- Two writers raced over the same row and this call lost.
Per-language constants
- Go
codes.Aborted- Java
Status.Code.ABORTED- Python
grpc.StatusCode.ABORTED- Node.js
status.ABORTED- C#
StatusCode.Aborted
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
11 OUT_OF_RANGE
The operation was attempted past the valid range — like reading beyond end-of-file. Unlike INVALID_ARGUMENT, the same request may become valid as state changes.
- Retry guidance
- No — The request ran past a valid range; iterators use this code as their stop signal, so adjust the offset instead of retrying.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 400.
Common causes
- A seek or read past the end of a file or list.
- A pagination loop walked past the last page and hit the designed stop signal.
Per-language constants
- Go
codes.OutOfRange- Java
Status.Code.OUT_OF_RANGE- Python
grpc.StatusCode.OUT_OF_RANGE- Node.js
status.OUT_OF_RANGE- C#
StatusCode.OutOfRange
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
12 UNIMPLEMENTED
The operation is not implemented, or not supported or enabled, in this service.
- Retry guidance
- No — The server does not implement or has not enabled the method; retrying the same server cannot change that.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 501.
Common causes
- The method name is not registered on the server build that answered.
- Version skew — a proxy or an older binary in the path does not know the RPC yet.
Per-language constants
- Go
codes.Unimplemented- Java
Status.Code.UNIMPLEMENTED- Python
grpc.StatusCode.UNIMPLEMENTED- Node.js
status.UNIMPLEMENTED- C#
StatusCode.Unimplemented
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
13 INTERNAL
An internal error: some invariant the underlying system expected has been broken. The docs reserve it for serious errors.
- Retry guidance
- Sometimes — see note — An invariant the server assumed was broken — at most one backed-off retry, then escalate to the service's own logs.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 500.
Common causes
- A broken invariant — the classic is a corrupted or truncated protobuf payload.
- Transport-level HTTP/2 framing errors between proxies surface as INTERNAL.
Per-language constants
- Go
codes.Internal- Java
Status.Code.INTERNAL- Python
grpc.StatusCode.INTERNAL- Node.js
status.INTERNAL- C#
StatusCode.Internal
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
14 UNAVAILABLE
The service is currently unavailable — most likely a transient condition around connectivity, load balancing or a restarting backend. The canonical retry-with-backoff code.
- Retry guidance
- Retry with backoff — The transient case the gRPC retry design was built for: retry with exponential backoff, and prefer retrying idempotent work.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 503.
Common causes
- The server is down or not listening — connection refused at the target address.
- A load balancer is draining or restarting the backend mid-deploy.
- The connection dropped mid-call — a GOAWAY from a proxy, a reset, or a keepalive timeout.
- TLS or ALPN misconfiguration keeps the channel from ever becoming ready.
Per-language constants
- Go
codes.Unavailable- Java
Status.Code.UNAVAILABLE- Python
grpc.StatusCode.UNAVAILABLE- Node.js
status.UNAVAILABLE- C#
StatusCode.Unavailable
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
15 DATA_LOSS
Unrecoverable data loss or corruption was detected.
- Retry guidance
- No — Unrecoverable loss or corruption — retrying cannot restore data; escalate instead of hammering.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 500.
Common causes
- The server detected unrecoverable corruption in stored data.
- A truncated write or a lost chunk was discovered on read.
Per-language constants
- Go
codes.DataLoss- Java
Status.Code.DATA_LOSS- Python
grpc.StatusCode.DATA_LOSS- Node.js
status.DATA_LOSS- C#
StatusCode.DataLoss
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
16 UNAUTHENTICATED
The request does not carry valid authentication credentials — who you are; PERMISSION_DENIED is about what you may do.
- Retry guidance
- No — Refresh or fix the credentials first, then send the call again.
- HTTP (grpc-gateway)
- grpc-gateway maps it to HTTP 401.
Common causes
- No credentials were attached to the call at all.
- An expired, malformed or wrong-audience token failed validation before authorisation was even checked.
Per-language constants
- Go
codes.Unauthenticated- Java
Status.Code.UNAUTHENTICATED- Python
grpc.StatusCode.UNAUTHENTICATED- Node.js
status.UNAUTHENTICATED- C#
StatusCode.Unauthenticated
Sources: Transcribed from grpc/grpc doc/statuscodes.md, google.rpc.Code (code.proto) and the grpc-gateway HTTPStatusFromCode mapping; retry posture per the gRPC retry design (gRFC A6).
Do it offline:$ grpcurl -v api.example.com:443 list
How to use it
- Press / to focus the search field, then type what you have: the bare number from the error, a name like UNAVAILABLE, or a constant pasted from a stack trace — codes.Unavailable and grpc.StatusCode.CANCELLED both resolve.
- Read the row: the meaning column is transcribed from the official statuscodes doc, the retry column is a cited posture rather than a promise, and the HTTP column shows what grpc-gateway would answer for a REST client.
- Follow a code's anchor for the deep entry — the common causes, the retry note in full, and the constant for each of five languages with a copy button beside it.
- Link a teammate straight to one code with its plain anchor, like #code-14. The Copy-link button shares only the view — what you typed in the search field is never encoded into a URL.
Your call failed with code 14 and the middle of an incident is no time to grep a proto file. This page lists all 17 canonical gRPC status codes with meaning, retry posture, common causes, per-language constants and the grpc-gateway HTTP mapping — every row cited to grpc.io sources. Search by number, name or a pasted constant; the lookup never leaves this page.
How it works
A gRPC status is not an HTTP status. When a call ends, the server reports the outcome in HTTP/2 trailers: grpc-status carries the numeric code and grpc-message a percent-encoded description. The HTTP-level :status is 200 even when the call failed — which is why a balancer that only watches HTTP codes can call a service healthy while every RPC inside it returns 14.
The canonical band is small on purpose. google.rpc.Code defines exactly 17 values, 0 through 16, shared by every implementation; nothing above the band is a gRPC status code. Services attach richer detail — retry delays, quota violations, field errors — in the grpc-status-details-bin trailer instead of minting new numbers.
Deadlines travel with the call: the client sets one, the grpc-timeout header propagates it hop by hop, and whichever hop runs out first answers 4 DEADLINE_EXCEEDED — so the code often names the slowest dependency in the chain, not the service you dialed. The retry postures in this table follow the gRPC retry design, which singles out 14 UNAVAILABLE as the code to retry with exponential backoff.
A browser page cannot open a native gRPC channel: browser HTTP APIs expose no HTTP/2 trailers, and grpc-web exists precisely because a translation layer — the server itself or a proxy in front of it — must sit in the middle. This reference is therefore a static, cited table — the search runs over rows already on the page, and no lookup can or does call out.
Examples
1414 UNAVAILABLE · Retry with backoff · HTTP 503 via grpc-gatewayThe head answer. UNAVAILABLE is the transient-connectivity code and the one the retry design names as safely retryable. Its detail section lists the classic causes: a dead backend, a draining load balancer, a dropped connection.
deadline4 DEADLINE_EXCEEDED · Sometimes — see note · HTTP 504 via grpc-gatewayFuzzy text search: deadline finds DEADLINE_EXCEEDED without the underscore, and its note warns the work may have finished after the client stopped waiting — retry only what is idempotent.
20That number is not a gRPC status code — the canonical codes run 0 through 16, and google.rpc.Code defines nothing outside that band. An HTTP-looking number belongs to the HTTP column, not the code column.The teaching refusal, byte-identical to the live banner: numbers outside the band get the band explained, never a guessed row — and 503 gets the same answer, because it is an HTTP code.
Every example on this page is executed against the same engine that powers the tool, on every build.
Gotchas worth knowing
OK is a status too
Code 0 is a real row, not the absence of one — success is reported through the same grpc-status trailer as every failure. Searching 0 answers OK, which helps when a log prints the bare number and you wonder whether it was an error at all.
UNKNOWN and INTERNAL are different admissions
UNKNOWN says the error could not be translated into a canonical code — classically an exception that escaped a handler. INTERNAL says the system saw its own invariant break. grpc-gateway maps both to HTTP 500, which is exactly why the gRPC code is the more informative signal.
DEADLINE_EXCEEDED is not quite a 504
grpc-gateway translates code 4 to HTTP 504, but the semantics differ: a gateway timeout blames an upstream, while a gRPC deadline is the client's own budget and can expire after the server quietly finished the work. That is why the retry note leads with idempotency.
The INVALID_ARGUMENT / FAILED_PRECONDITION / OUT_OF_RANGE triad
The docs draw a litmus test. INVALID_ARGUMENT: the request is wrong in any system state. FAILED_PRECONDITION: the state, not the request, is wrong — fix it explicitly before retrying. OUT_OF_RANGE: the request ran past a valid range and may become valid as state changes; iterators use it as their stop signal.
One code, three spellings
The same status is codes.Canceled in Go — one L — but grpc.StatusCode.CANCELLED in Python and StatusCode.Cancelled in C#. Paste whichever spelling your stack trace shows: each row's constants are part of its search text.
grpc-web frames its trailers differently
Browsers cannot read HTTP/2 trailers, so grpc-web re-encodes the status block as a trailer frame inside the response body; a proxy or the server itself translates between the two wires. The codes themselves are unchanged — this table applies — but the framing is its own protocol.
Common errors
That query is longer than 64 characters — only its first 64 were read. A gRPC status code is at most two digits and no canonical status name is longer than 19 characters.- The cap refusal. The field never silently clips: the lookup reads the first 64 characters, answers from them, and says so.
An empty search is not an error — the full table of 17 status codes is shown.- Not a failure state at all: the resting state of a reference page is the whole reference. The typed note exists so engine consumers get an explanation instead of a silent default.
That number is not a gRPC status code — the canonical codes run 0 through 16, and google.rpc.Code defines nothing outside that band. An HTTP-looking number belongs to the HTTP column, not the code column.- The refusal for 17, 100, 503 and negatives alike. The canonical band is closed, so an out-of-band number is answered by teaching, never by a guessed row.
Nothing on this page matches that — all 17 canonical gRPC status codes are listed here, so try the number, the SCREAMING_SNAKE name, or a word from a meaning.- The zero-result state names its own way out. Nothing dead-ends: clearing the field restores the full table instantly.
FAQ
What does gRPC status code 14 (UNAVAILABLE) mean?
Code 14 means the service was unavailable when the call was attempted — usually transient: the backend is down or restarting, a load balancer is draining it, or the connection dropped mid-call. It is the one code the gRPC retry design names as safe to retry with exponential backoff, ideally for idempotent work.
Why is the HTTP status 200 on a failed gRPC call?
Because gRPC does not report outcomes at the HTTP layer. The :status is 200 whenever the protocol exchange itself worked; the real result rides the grpc-status trailer after the message bytes. Anything judging a gRPC backend by HTTP status alone — dashboards, balancers, generic probes — will call failures healthy.
Which gRPC status codes are safe to retry?
Only 14 UNAVAILABLE is singled out as generally retryable, with exponential backoff. RESOURCE_EXHAUSTED, ABORTED, DEADLINE_EXCEEDED, UNKNOWN and INTERNAL are conditional — each retry note here says what must be true first. The rest fail the same way until something is fixed, so retrying them is noise.
Are gRPC status codes the same as HTTP status codes?
No — they are a separate 17-value space defined by google.rpc.Code. The HTTP column in this table is grpc-gateway's translation for REST clients, and it is lossy: three different gRPC codes all become HTTP 500, and another three become 400. The gRPC code is always the more precise signal.
Can I see gRPC status codes in my browser's network tab?
Not from a plain gRPC service — browsers do not expose HTTP/2 trailers, which is where grpc-status lives. With grpc-web the status block is re-framed inside the response body, visible but not as a header. This page probes nothing: every row is a cited transcription, and the search stays on this device.
What is grpc-status-details-bin?
A trailer carrying a serialized google.rpc.Status message — how services attach structured detail such as retry delays or field violations to a canonical code. This page cites that it exists rather than decoding it: the payload is base64 protobuf and service-specific.
Keyboard shortcuts
- /
- Focus the search field