All services

Anthropic Claude API errors: invalid_request_error (400), authentication_error (401), permission_error (403), rate_limit_error (429), api_error (500), overloaded_error (529).

OpenAI API errors: insufficient_quota (402), rate_limit_exceeded (429), invalid_request_error, model_not_found, context_length_exceeded. Most production pain comes from token limits and tier-based RPM caps.

Auth0 errors: invalid_grant (refresh failed), unauthorized_client, access_denied, login_required, consent_required, mfa_required. Rate limits per Management API endpoint and Authentication API.

AWS spans 200+ services, each with its own error catalogue. Common failures: IAM permissions (AccessDeniedException), S3 (NoSuchBucket, 403), Lambda (timeout, throttling), DynamoDB (ProvisionedThroughputExceededException).

Google Cloud surfaces errors via gRPC status codes (PERMISSION_DENIED, RESOURCE_EXHAUSTED, UNAVAILABLE) and HTTP error responses. Common failure modes: IAM, quota limits, regional outages.

Cloudflare error codes start with 5xx (520-530 series) for origin issues, 1xxx for Workers, 1000-series for security blocks. Most common: 520 (web server returned unknown error), 522 (origin timeout), 524 (origin response timeout).

Django errors: ImproperlyConfigured, OperationalError (database), DoesNotExist, MultipleObjectsReturned, IntegrityError, TemplateDoesNotExist, FieldError, MigrationSchemaMissing.

Express errors: 'Cannot set headers after they are sent', 'TypeError: req.body is undefined', 'PayloadTooLargeError', middleware error not caught, missing next() call, async error not propagated.

FastAPI errors: RequestValidationError (422), HTTPException (custom), missing dependency injection, async DB session lifecycle errors, CORS preflight failures, JWT validation errors.

Laravel errors: 419 (CSRF token mismatch), QueryException, ModelNotFoundException, MassAssignmentException, ValidationException, InvalidArgumentException, MethodNotAllowedHttpException.

Next.js errors: 'Hydration failed', 'Module not found', 'getServerSideProps' failures, ISR revalidation errors, 'Image Optimization' errors, 'Failed to compile', 'Error: Connection terminated'.

Rails errors: ActiveRecord::RecordNotFound, ActiveRecord::RecordInvalid, RoutingError, ActionController::ParameterMissing, NoMethodError on nil, PG::ConnectionBad, deadlock detected.

Docker errors: 'no such image', 'driver failed programming external connectivity', 'manifest unknown', exit code 137 (OOM), exit code 139 (segfault), exit code 125 (Docker daemon error).

Kubernetes pod statuses: ImagePullBackOff, CrashLoopBackOff, ErrImagePull, OOMKilled, CreateContainerConfigError, RunContainerError. Most issues trace to image pull, resource limits, or config maps/secrets.

Nginx errors: 502 Bad Gateway (upstream connect failed), 504 Gateway Timeout (upstream read timeout), 413 Request Entity Too Large, 'too many open files', 'upstream prematurely closed'.

Firebase errors split by product: Auth (auth/email-already-in-use), Firestore (permission-denied, resource-exhausted), Cloud Functions (deadline-exceeded, unavailable), FCM (registration-token-not-registered).

Supabase errors: 401 invalid JWT, 403 RLS policy violation, 406 invalid query, 409 unique constraint, 503 capacity. Most issues are RLS policy mistakes or PostgREST query errors.

GitHub API errors come in three flavours: REST (HTTP status), GraphQL (typed errors), and Actions (workflow failures). Rate limits (5000/hr authenticated) and SSO authorization are the most common production blockers.

Go errors aren't exceptions — they're return values. Common patterns: 'connection refused', 'context deadline exceeded', 'panic: runtime error', 'concurrent map writes', 'no such file or directory'.

Node.js errors: ECONNREFUSED, ETIMEDOUT, EADDRINUSE, ERR_MODULE_NOT_FOUND, ERR_REQUIRE_ESM, EACCES, UnhandledPromiseRejection, MaxListenersExceededWarning, JavaScript heap out of memory.

Python exceptions: ImportError, ModuleNotFoundError, TypeError, ValueError, AttributeError, IndexError, KeyError, FileNotFoundError, ConnectionError, TimeoutError, RecursionError.

Rust errors are typed Result<T, E> values, but compile-time issues dominate: borrow checker errors (E0382, E0502), lifetime errors, trait bound errors, type mismatch (E0308). Panics: unwrap on None, index out of bounds.

MongoDB errors: 11000 (duplicate key), 50 (operation timeout), 89 (network timeout), 13 (auth failure), 121 (document validation), 133 (FailedToSatisfyReadPreference), 134 (ReadConcernMajorityNotAvailableYet).

MySQL errors use numeric codes: 1062 (duplicate entry), 1452 (foreign key fails), 1205 (lock wait timeout), 1213 (deadlock), 2002 (connection refused), 2013 (lost connection during query).

Postgres errors use 5-character SQLSTATE codes: 23505 (unique violation), 23503 (foreign key violation), 40P01 (deadlock), 53300 (too many connections), 57P03 (cannot connect now).

Redis errors: WRONGTYPE (operation against wrong type key), MOVED (cluster redirect), ASK (cluster slot migrating), READONLY (replica write attempt), OOM (out of memory), MAXCLIENTS REACHED.

PayPal Payments API errors are returned as `name` + `message` + `details` triples. Common production failures: INSTRUMENT_DECLINED (card declined), AUTHENTICATION_FAILURE (expired OAuth token), VALIDATION_ERROR, RATE_LIMIT_REACHED.

Stripe processes payments for millions of businesses. Its API surfaces decline reasons, webhook signatures, idempotency conflicts, and rate limits as structured error codes.

Shopify Admin API errors: 401 invalid API key, 402 unpaid plan, 403 scope mismatch, 422 invalid resource, 429 throttled. GraphQL throttling uses cost-based bucket (1000 points, 50/sec leak).

Slack Web API errors: invalid_auth, not_authed, account_inactive, missing_scope, channel_not_found, rate_limited. Tier-based rate limits (Tier 1: 1 req/min, Tier 4: 100+/min).

Twilio errors are 5-digit codes (e.g., 21211 invalid 'To' number, 30003 unreachable destination, 20003 authentication error). SMS delivery failures (3xxxx) are the most common production issue.

Vercel deploy errors: build failures, function timeouts (FUNCTION_INVOCATION_TIMEOUT), DNS issues (DEPLOYMENT_NOT_FOUND), edge runtime errors. Most issues trace to env vars, build commands, or function size limits.