# Update a workspace API key

`PATCH https://api.lingohub.com/v2/api-keys/{apiKeyId}`

LingoHub API V2 (Beta) · [API Keys](https://developers.lingohub.com/reference/v2/operations/tags/api-keys.md) · operation `updateWorkspaceApiKey`

Renames a workspace-managed key or changes its description or expiry date; its scope, permissions and token stay the same. `null` clears the description or removes the expiry. Personal and deactivated keys can't be changed here (409). Requires workspace-level API access management permission.

## Parameters

| Parameter | In | Required | Type | Description |
| --- | --- | --- | --- | --- |
| `apiKeyId` | path | yes | string |  |
| `If-Match` | header | no | string | Optional precondition. Send the quoted ETag from a GET of this resource. The mutation only runs if a strong tag matches the current representation, checked under the write lock. A comma-separated list is allowed; '*' req… |

## Example request

```sh
curl --request PATCH \
  --url https://api.lingohub.com/v2/api-keys/API_KEY_ID \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
  "name": "Automation",
  "description": "CI import key",
  "expiration_date": "2027-01-31"
}'
```

## Responses

- `200`: Workspace API key updated.
- `400`: 
- `401`: 
- `403`: 
- `404`: 
- `409`: `conflict`: the key is a personal key, which only its owner manages, or it is deactivated or expired.
- `412`: 
- `422`: 
- `429`: 
- `500`: 
- `503`: 

## OpenAPI definition

The complete definition of this operation, with every schema it references:

````json
{
  "openapi": "3.1.0",
  "info": {
    "title": "LingoHub API V2 (Beta)",
    "version": "2.0"
  },
  "servers": [
    {
      "url": "https://api.lingohub.com",
      "description": "LingoHub"
    }
  ],
  "tags": [
    {
      "name": "API Keys",
      "description": "Check the API key a request is made with, and read and rename the workspace's API keys."
    }
  ],
  "paths": {
    "/v2/api-keys/{apiKeyId}": {
      "patch": {
        "tags": [
          "API Keys"
        ],
        "summary": "Update a workspace API key",
        "description": "Renames a workspace-managed key or changes its description or expiry date; its scope, permissions and token stay the same. `null` clears the description or removes the expiry. Personal and deactivated keys can't be changed here (409). Requires workspace-level API access management permission.",
        "operationId": "updateWorkspaceApiKey",
        "parameters": [
          {
            "name": "apiKeyId",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "description": "Public id that is created from the type prefix of the corresponding resource and its UUID. I.e : For an API key, a valid value would be : api_0197c8f2-5a6b-7cde-8f12-3456789abcde",
              "pattern": "^api_[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
            }
          },
          {
            "name": "If-Match",
            "in": "header",
            "description": "Optional precondition. Send the quoted ETag from a GET of this resource. The mutation only runs if a strong tag matches the current representation, checked under the write lock. A comma-separated list is allowed; '*' requires an existing representation. Weak tags never match. Omit this header for an unconditional write. For an action, use the ETag from GET of the target resource, without the action suffix. A stale tag returns 412; read the current state before retrying.",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/UpdateWorkspaceApiKey"
              }
            },
            "application/merge-patch+json": {
              "schema": {
                "$ref": "#/components/schemas/UpdateWorkspaceApiKey"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Workspace API key updated.",
            "headers": {
              "ETag": {
                "$ref": "#/components/headers/ETag"
              },
              "RateLimit": {
                "$ref": "#/components/headers/RateLimit"
              },
              "RateLimit-Policy": {
                "$ref": "#/components/headers/RateLimit-Policy"
              }
            },
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ApiKey"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "description": "`conflict`: the key is a personal key, which only its owner manages, or it is deactivated or expired.",
            "headers": {
              "RateLimit": {
                "$ref": "#/components/headers/RateLimit"
              },
              "RateLimit-Policy": {
                "$ref": "#/components/headers/RateLimit-Policy"
              }
            },
            "content": {
              "application/problem+json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "412": {
            "$ref": "#/components/responses/PreconditionFailed"
          },
          "422": {
            "$ref": "#/components/responses/UnprocessableContent"
          },
          "429": {
            "$ref": "#/components/responses/TooManyRequests"
          },
          "500": {
            "$ref": "#/components/responses/InternalServerError"
          },
          "503": {
            "$ref": "#/components/responses/ServiceUnavailable"
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    }
  },
  "components": {
    "schemas": {
      "UpdateWorkspaceApiKey": {
        "type": "object",
        "additionalProperties": false,
        "description": "Request body to partially update active workspace-managed key metadata without changing its permissions or ownership.",
        "properties": {
          "name": {
            "type": "string",
            "description": "Display name, unique among workspace-managed keys.",
            "example": "Automation",
            "maxLength": 4096
          },
          "description": {
            "type": [
              "string",
              "null"
            ],
            "description": "Optional description; null clears it.",
            "example": "CI import key",
            "maxLength": 4096
          },
          "expiration_date": {
            "type": [
              "string",
              "null"
            ],
            "format": "date",
            "description": "Last valid day, inclusive, in UTC. Null means no configured expiration.",
            "example": "2027-01-31"
          }
        }
      },
      "ApiKey": {
        "type": "object",
        "description": "An API key of the workspace, without its token. Only getApiKey includes the permissions, for the key the request is made with.",
        "properties": {
          "object_type": {
            "type": "string",
            "description": "Always `API_KEY`.",
            "enum": [
              "API_KEY"
            ],
            "example": "API_KEY"
          },
          "id": {
            "type": "string",
            "description": "Unique identifier of the API key.",
            "example": "api_0197c8f2-5a6b-7cde-8f12-3456789abcde",
            "minLength": 1,
            "pattern": "^api_[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
          },
          "name": {
            "type": "string",
            "description": "Name of the API key.",
            "example": "CI pipeline"
          },
          "description": {
            "type": [
              "string",
              "null"
            ],
            "description": "Description of the API key.",
            "example": "Pushes translations from the release pipeline."
          },
          "scope": {
            "$ref": "#/components/schemas/ApiKeyScope",
            "description": "What the API key reaches.",
            "example": "WORKSPACE"
          },
          "management_mode": {
            "$ref": "#/components/schemas/ApiKeyManagementMode",
            "description": "Whose permissions the API key follows: `WORKSPACE_MANAGED` keys act with the permissions stored on the key, `USER_OWNED` keys with the current permissions of the member in `member_id`.",
            "example": "WORKSPACE_MANAGED"
          },
          "workspace_id": {
            "type": "string",
            "description": "Unique identifier of the workspace the API key belongs to.",
            "example": "space_0197c8f2-5a6b-7cde-8f12-3456789abcde",
            "pattern": "^space_[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
          },
          "stack_id": {
            "type": [
              "string",
              "null"
            ],
            "description": "The only stack a `STACK` key reaches; null for the other scopes and once that stack is deleted.",
            "pattern": "^stack_[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
          },
          "member_id": {
            "type": [
              "string",
              "null"
            ],
            "description": "The member a personal (`USER_OWNED`) key belongs to or a `USER` key is assigned to; null for other keys and once that member has left the workspace.",
            "pattern": "^wsu_[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
          },
          "expires_at": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time",
            "description": "When the API key stops working: the end of its last valid day in UTC. Null when it does not expire.",
            "example": "2027-01-01T00:00:00.123Z"
          },
          "last_used_at": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time",
            "description": "When the API key was last used, to the minute; null when it has not been used.",
            "example": "2026-09-30T12:00:00.123Z"
          },
          "deactivated_at": {
            "type": [
              "string",
              "null"
            ],
            "format": "date-time",
            "description": "When the API key was deactivated; null while it is active. A deactivated key no longer works.",
            "example": "2026-10-01T08:00:00.123Z"
          },
          "deactivation_reason": {
            "description": "Why the API key was deactivated; null while it is active.",
            "example": "MANUAL_REVOCATION",
            "oneOf": [
              {
                "$ref": "#/components/schemas/ApiKeyDeactivationReason"
              },
              {
                "type": "null"
              }
            ]
          },
          "created_at": {
            "type": "string",
            "format": "date-time",
            "description": "When the API key was created.",
            "example": "2026-01-15T10:30:00.123Z"
          },
          "updated_at": {
            "type": "string",
            "format": "date-time",
            "description": "When the API key was last changed; using it doesn't count as a change.",
            "example": "2026-06-20T14:45:00.123Z"
          },
          "permissions": {
            "type": [
              "array",
              "null"
            ],
            "description": "The current permissions of the key the request is made with: one per workspace area, and one per stack area that applies to every stack the key reaches, unless `stack_permissions` names the stack. Only getApiKey fills it; null elsewhere.",
            "example": [
              {
                "scope": "STACK",
                "target": "RESOURCES",
                "level": "MANAGE"
              }
            ],
            "items": {
              "$ref": "#/components/schemas/Permission"
            }
          },
          "stack_permissions": {
            "type": [
              "array",
              "null"
            ],
            "description": "The stacks on which the key's stack permissions differ from those in `permissions`. Only getApiKey fills it; null elsewhere.",
            "example": [
              {
                "stack_id": "stack_0197c8f2-5a6b-7cde-8f12-3456789abcde",
                "permissions": [
                  {
                    "scope": "STACK",
                    "target": "RESOURCES",
                    "level": "MANAGE"
                  }
                ]
              }
            ],
            "items": {
              "$ref": "#/components/schemas/StackPermissions"
            }
          }
        },
        "required": [
          "created_at",
          "deactivated_at",
          "deactivation_reason",
          "description",
          "expires_at",
          "id",
          "last_used_at",
          "management_mode",
          "member_id",
          "name",
          "object_type",
          "permissions",
          "scope",
          "stack_id",
          "stack_permissions",
          "updated_at",
          "workspace_id"
        ]
      },
      "ApiKeyScope": {
        "type": "string",
        "description": "What the API key reaches. A `WORKSPACE` key reaches the workspace's stacks, a `STACK` key only the stack in `stack_id`, and a `USER` key is assigned to the member in `member_id`. User-owned keys use the member's current permissions; workspace-managed keys assigned to a user retain their configured permissions.",
        "enum": [
          "WORKSPACE",
          "STACK",
          "USER"
        ]
      },
      "ApiKeyManagementMode": {
        "type": "string",
        "description": "Who manages the API key and determines its permissions.",
        "enum": [
          "WORKSPACE_MANAGED",
          "USER_OWNED"
        ]
      },
      "ApiKeyDeactivationReason": {
        "type": "string",
        "description": "The stored cause of API key deactivation.",
        "enum": [
          "EXPIRATION_DATE",
          "WORKSPACE_USER_REMOVED",
          "STACK_DELETED",
          "MANUAL_REVOCATION",
          "SELF_SERVICE_DISABLED"
        ]
      },
      "Permission": {
        "type": "object",
        "description": "The access level the represented principal has to one area, in the vocabulary of `required_permission` in 403 responses.",
        "properties": {
          "scope": {
            "$ref": "#/components/schemas/PermissionScope",
            "description": "Where the permission applies.",
            "example": "STACK"
          },
          "target": {
            "$ref": "#/components/schemas/PermissionTarget",
            "description": "The area the permission governs.",
            "example": "RESOURCES"
          },
          "level": {
            "$ref": "#/components/schemas/PermissionLevel",
            "description": "The access level granted.",
            "example": "MANAGE"
          }
        },
        "required": [
          "level",
          "scope",
          "target"
        ]
      },
      "PermissionScope": {
        "type": "string",
        "description": "Where a permission applies: `WORKSPACE` permissions cover workspace-level resources, `STACK` permissions the resources of a stack (its projects, branches, resources, languages, ...).",
        "enum": [
          "WORKSPACE",
          "STACK"
        ]
      },
      "PermissionTarget": {
        "type": "string",
        "description": "The area a permission governs.",
        "enum": [
          "GENERAL",
          "BILLING_SUBSCRIPTION",
          "WORKSPACES",
          "MEMBERS",
          "PLUGINS_INTEGRATIONS",
          "LOGS",
          "API_ACCESS",
          "STACKS",
          "TRANSLATION_ORDERS",
          "WORK_REPORTS",
          "STYLE_GUIDES",
          "GLOSSARIES",
          "TRANSLATION_MEMORIES",
          "LABELS",
          "AI_TRANSLATION",
          "QUICK_TRANSLATIONS",
          "SETTINGS",
          "ACTIVITIES",
          "RESOURCES",
          "CONTEXT_IMAGES",
          "LANGUAGES",
          "SEGMENT_KEYS",
          "SEGMENTS",
          "SEGMENT_TEXTS"
        ]
      },
      "PermissionLevel": {
        "type": "string",
        "description": "Access level of a permission: `MANAGE` includes `WRITE` and `VIEW`.",
        "enum": [
          "NO_ACCESS",
          "VIEW",
          "WRITE",
          "MANAGE"
        ]
      },
      "StackPermissions": {
        "type": "object",
        "description": "The API key's stack permissions for one stack where they differ from its default.",
        "properties": {
          "stack_id": {
            "type": "string",
            "description": "Unique identifier of the stack.",
            "example": "stack_0197c8f2-5a6b-7cde-8f12-3456789abcde",
            "pattern": "^stack_[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
          },
          "permissions": {
            "type": "array",
            "description": "The permissions on this stack, one per stack area.",
            "example": [
              {
                "scope": "STACK",
                "target": "RESOURCES",
                "level": "MANAGE"
              }
            ],
            "items": {
              "$ref": "#/components/schemas/Permission"
            }
          }
        },
        "required": [
          "permissions",
          "stack_id"
        ]
      },
      "Error": {
        "type": "object",
        "description": "RFC 9457 problem details. `code` identifies the problem type (one per `type` URL); `errors` lists rejected fields or parameters; `required_permission` names the permission a 403 lacked.",
        "properties": {
          "type": {
            "type": "string",
            "description": "URL identifying the problem type and pointing to its documentation.",
            "example": "https://api.lingohub.com/errors/resource-not-found"
          },
          "title": {
            "type": "string",
            "description": "Short, constant summary of the problem type.",
            "example": "Resource not found"
          },
          "status": {
            "type": "integer",
            "format": "int32",
            "description": "HTTP status code.",
            "example": 404
          },
          "detail": {
            "type": "string",
            "description": "Human-readable explanation of this occurrence of the problem.",
            "example": "Resource with ID 'pr_0197c8f2-5a6b-7cde-8f12-3456789abcde' was not found."
          },
          "instance": {
            "type": "string",
            "description": "Path of the request that produced the problem.",
            "example": "/v2/projects/pr_0197c8f2-5a6b-7cde-8f12-3456789abcde"
          },
          "code": {
            "$ref": "#/components/schemas/ErrorCode",
            "description": "Machine-readable problem type.",
            "example": "resource_not_found"
          },
          "request_id": {
            "type": "string",
            "description": "Correlation id of the request, also returned in the `X-Request-ID` header. Quote it when contacting support.",
            "example": "f47ac10b-58cc-4372-a567-0e02b2c3d479"
          },
          "errors": {
            "type": "array",
            "description": "Rejected fields or parameters. Present when the problem concerns specific fields or parameters.",
            "example": [
              {
                "detail": "must be at least 2 characters long",
                "pointer": "#/name",
                "parameter": "limit",
                "code": "minLength"
              }
            ],
            "items": {
              "$ref": "#/components/schemas/FieldError"
            }
          },
          "required_permission": {
            "$ref": "#/components/schemas/RequiredPermission",
            "description": "The permission the API key lacks. Present on 403 responses."
          }
        },
        "required": [
          "code",
          "detail",
          "instance",
          "request_id",
          "status",
          "title",
          "type"
        ]
      },
      "ErrorCode": {
        "type": "string",
        "description": "Machine-readable problem type of a V2 error response. Each code has a fixed HTTP status and documentation at its `type` URL.",
        "enum": [
          "invalid_json",
          "invalid_parameter",
          "missing_parameter",
          "unknown_parameter",
          "invalid_filter",
          "invalid_cursor",
          "bad_request",
          "missing_api_key",
          "invalid_api_key",
          "expired_api_key",
          "revoked_api_key",
          "disabled_api_key",
          "insufficient_permissions",
          "resource_not_found",
          "route_not_found",
          "method_not_allowed",
          "not_acceptable",
          "precondition_failed",
          "content_too_large",
          "unsupported_media_type",
          "already_exists",
          "idempotency_outcome_unknown",
          "idempotency_key_in_use",
          "stack_not_empty",
          "branch_not_ready",
          "backup_not_ready",
          "backup_in_use",
          "default_branch_protected",
          "owner_membership_protected",
          "source_language_protected",
          "branch_limit_reached",
          "context_image_limit_reached",
          "automation_limit_reached",
          "translation_order_pending",
          "git_integration_not_configured",
          "branch_git_integration_not_configured",
          "git_integration_unauthorized",
          "conflict",
          "validation_failed",
          "idempotency_key_mismatch",
          "rate_limit_exceeded",
          "internal_error",
          "upstream_error",
          "service_unavailable",
          "upstream_timeout"
        ]
      },
      "FieldError": {
        "type": "object",
        "description": "A rejected field or parameter. `pointer` locates a body field (RFC 6901 JSON Pointer), `parameter` a query, path or header parameter or a field of a multipart upload; both are set for a position inside a JSON-valued parameter such as `filter`.",
        "properties": {
          "detail": {
            "type": "string",
            "description": "Human-readable description of the problem.",
            "example": "must be at least 2 characters long"
          },
          "pointer": {
            "type": [
              "string",
              "null"
            ],
            "description": "JSON Pointer to the offending body field, or to the position inside a JSON-valued parameter.",
            "example": "#/name"
          },
          "parameter": {
            "type": [
              "string",
              "null"
            ],
            "description": "Name of the offending query, path or header parameter, or of the multipart form field.",
            "example": "limit"
          },
          "code": {
            "$ref": "#/components/schemas/FieldErrorCode",
            "description": "Why the field or parameter was rejected.",
            "example": "minLength"
          }
        },
        "required": [
          "code",
          "detail",
          "parameter",
          "pointer"
        ]
      },
      "FieldErrorCode": {
        "type": "string",
        "description": "Why a field or parameter was rejected: the JSON Schema keyword of the violated rule, or one of the documented rules that no schema can express.",
        "enum": [
          "required",
          "type",
          "enum",
          "minLength",
          "maxLength",
          "minimum",
          "maximum",
          "pattern",
          "format",
          "additionalProperties",
          "minItems",
          "maxItems",
          "uniqueItems",
          "already_exists",
          "not_found",
          "not_supported",
          "unsupported_file_extension",
          "file_too_large",
          "file_empty",
          "invalid_archive",
          "empty_archive"
        ]
      },
      "RequiredPermission": {
        "type": "object",
        "description": "The permission the API key lacks, in the vocabulary of the API key permission settings.",
        "properties": {
          "scope": {
            "$ref": "#/components/schemas/PermissionScope",
            "description": "Where the permission applies.",
            "example": "STACK"
          },
          "target": {
            "$ref": "#/components/schemas/PermissionTarget",
            "description": "The area the permission governs.",
            "example": "SETTINGS"
          },
          "level": {
            "$ref": "#/components/schemas/PermissionLevel",
            "description": "The access level required.",
            "example": "MANAGE"
          }
        },
        "required": [
          "level",
          "scope",
          "target"
        ]
      }
    },
    "headers": {
      "ETag": {
        "description": "Opaque strong validator for this representation. Keep its quotation marks and use it as If-Match on a documented conditional write. A replay carries the original ETag, which may now be stale.",
        "schema": {
          "type": "string"
        }
      },
      "RateLimit": {
        "description": "State of the rate-limit policy currently closest to rejection (IETF draft-ietf-httpapi-ratelimit-headers): the quoted policy name with `r` = requests remaining right now and `t` = seconds until the full quota is available again. Example: `\"api-key\";r=42;t=7`. Advisory: absent when the request fails authentication or the limiter state is momentarily unknown.",
        "schema": {
          "type": "string"
        }
      },
      "RateLimit-Policy": {
        "description": "The rate-limit policies applied to the request: each quoted policy name with `q` = sustained request quota per window of `w` seconds. Example: `\"api-key\";q=180;w=60, \"workspace\";q=600;w=60`. Advisory: absent when the request fails authentication or the limiter state is momentarily unknown.",
        "schema": {
          "type": "string"
        }
      },
      "Retry-After": {
        "description": "Seconds to wait before retrying.",
        "schema": {
          "type": "integer",
          "format": "int32"
        }
      }
    },
    "responses": {
      "BadRequest": {
        "description": "The request is malformed: an unknown or invalid query parameter, an invalid id in the path, or a body that is not valid JSON. `code` names the problem, `errors` the parameter or field.",
        "headers": {
          "RateLimit": {
            "$ref": "#/components/headers/RateLimit"
          },
          "RateLimit-Policy": {
            "$ref": "#/components/headers/RateLimit-Policy"
          }
        },
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "Unauthorized": {
        "description": "Invalid or missing API key.",
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "Forbidden": {
        "description": "Insufficient permissions.",
        "headers": {
          "RateLimit": {
            "$ref": "#/components/headers/RateLimit"
          },
          "RateLimit-Policy": {
            "$ref": "#/components/headers/RateLimit-Policy"
          }
        },
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "NotFound": {
        "description": "The resource does not exist, or the API key cannot see it.",
        "headers": {
          "RateLimit": {
            "$ref": "#/components/headers/RateLimit"
          },
          "RateLimit-Policy": {
            "$ref": "#/components/headers/RateLimit-Policy"
          }
        },
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "PreconditionFailed": {
        "description": "The current representation does not match If-Match (`precondition_failed`). No change was applied.",
        "headers": {
          "RateLimit": {
            "$ref": "#/components/headers/RateLimit"
          },
          "RateLimit-Policy": {
            "$ref": "#/components/headers/RateLimit-Policy"
          }
        },
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "UnprocessableContent": {
        "description": "The request is well-formed, but values are invalid; `errors` points at each of them.",
        "headers": {
          "RateLimit": {
            "$ref": "#/components/headers/RateLimit"
          },
          "RateLimit-Policy": {
            "$ref": "#/components/headers/RateLimit-Policy"
          }
        },
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "TooManyRequests": {
        "description": "The API rate limit was exceeded. Wait for the number of seconds given in the Retry-After header, then retry.",
        "headers": {
          "Retry-After": {
            "$ref": "#/components/headers/Retry-After"
          },
          "RateLimit": {
            "$ref": "#/components/headers/RateLimit"
          },
          "RateLimit-Policy": {
            "$ref": "#/components/headers/RateLimit-Policy"
          }
        },
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "InternalServerError": {
        "description": "An unexpected internal server error occurred.",
        "headers": {
          "RateLimit": {
            "$ref": "#/components/headers/RateLimit"
          },
          "RateLimit-Policy": {
            "$ref": "#/components/headers/RateLimit-Policy"
          }
        },
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "ServiceUnavailable": {
        "description": "The service is temporarily unavailable. Retry after the number of seconds in the Retry-After header.",
        "headers": {
          "Retry-After": {
            "$ref": "#/components/headers/Retry-After"
          },
          "RateLimit": {
            "$ref": "#/components/headers/RateLimit"
          },
          "RateLimit-Policy": {
            "$ref": "#/components/headers/RateLimit-Policy"
          }
        },
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      }
    },
    "securitySchemes": {
      "bearerAuth": {
        "type": "http",
        "description": "API key authentication. Create API keys in your LingoHub workspace settings. Keys use the `lh-api_` prefix. Pass the full key as the Bearer token.",
        "scheme": "bearer"
      }
    }
  }
}
````
