# Replace integration authentication credentials

`PUT https://api.lingohub.com/v2/integration-authentications/{integrationAuthenticationId}/credentials`

LingoHub API V2 (Beta) · [Integration Authentications](https://developers.lingohub.com/reference/v2/operations/tags/integration-authentications.md) · operation `setIntegrationAuthenticationCredentials`

Replaces the token or keys of a connection entered by hand; send the complete set, in the same shape as when creating it. Content-platform credentials are checked with the provider first; git tokens are stored as given. GitHub App installations and OAuth sign-ins can't be changed here (409). Send the ETag from getIntegrationAuthentication as If-Match to make sure nobody changed the connection in between. Requires workspace-level integration management permission.

## Parameters

| Parameter | In | Required | Type | Description |
| --- | --- | --- | --- | --- |
| `integrationAuthenticationId` | 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 PUT \
  --url https://api.lingohub.com/v2/integration-authentications/INTEGRATION_AUTHENTICATION_ID/credentials \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
  "provider": "AZURE",
  "access_token": "provider-token"
}'
```

## Responses

- `200`: Credential-free metadata. GET the authentication for its current ETag.
- `400`: 
- `401`: 
- `403`: 
- `404`: 
- `409`: `conflict`: only manually provisioned credentials can be replaced.
- `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": "Integration Authentications",
      "description": "Manage the stored credentials LingoHub uses to connect to Git providers and content platforms."
    }
  ],
  "paths": {
    "/v2/integration-authentications/{integrationAuthenticationId}/credentials": {
      "put": {
        "tags": [
          "Integration Authentications"
        ],
        "summary": "Replace integration authentication credentials",
        "description": "Replaces the token or keys of a connection entered by hand; send the complete set, in the same shape as when creating it. Content-platform credentials are checked with the provider first; git tokens are stored as given. GitHub App installations and OAuth sign-ins can't be changed here (409). Send the ETag from getIntegrationAuthentication as If-Match to make sure nobody changed the connection in between. Requires workspace-level integration management permission.",
        "operationId": "setIntegrationAuthenticationCredentials",
        "parameters": [
          {
            "name": "integrationAuthenticationId",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "description": "Public id composed of the resource type prefix and its UUID.",
              "pattern": "^iau_[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/SetIntegrationAuthenticationCredentials"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Credential-free metadata. GET the authentication for its current ETag.",
            "headers": {
              "RateLimit": {
                "$ref": "#/components/headers/RateLimit"
              },
              "RateLimit-Policy": {
                "$ref": "#/components/headers/RateLimit-Policy"
              }
            },
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/IntegrationAuthentication"
                },
                "example": {
                  "object_type": "INTEGRATION_AUTHENTICATION",
                  "id": "iau_0197c8f2-5a6b-7cde-8f12-3456789abcde",
                  "name": "Company GitLab",
                  "provider": "GITLAB",
                  "type": "MANUAL",
                  "status": "ACTIVE",
                  "is_self_hosted": false,
                  "provider_origin": "https://gitlab.com",
                  "provider_region": null,
                  "created_at": "2025-01-15T10:30:00.123Z",
                  "updated_at": "2025-01-15T10:30:00.123Z"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "description": "`conflict`: only manually provisioned credentials can be replaced.",
            "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": {
      "SetIntegrationAuthenticationCredentials": {
        "type": "object",
        "description": "Request body to replace the complete credentials of a manual authentication. `provider` selects the shape of the body and must be the authentication's stored provider.",
        "discriminator": {
          "propertyName": "provider",
          "mapping": {
            "AZURE": "#/components/schemas/SetTokenCredentials",
            "BITBUCKET": "#/components/schemas/SetTokenCredentials",
            "CONTENTFUL": "#/components/schemas/SetTokenCredentials",
            "HUBSPOT": "#/components/schemas/SetTokenCredentials",
            "STRIPO": "#/components/schemas/SetTokenCredentials",
            "GITLAB": "#/components/schemas/SetGitLabCredentials",
            "AWS_CODE_COMMIT": "#/components/schemas/SetCodeCommitCredentials",
            "STORYBLOK": "#/components/schemas/SetStoryblokCredentials",
            "ZENDESK": "#/components/schemas/SetZendeskCredentials",
            "CRISP_HELPDESK": "#/components/schemas/SetCrispHelpdeskCredentials"
          }
        },
        "oneOf": [
          {
            "$ref": "#/components/schemas/SetTokenCredentials"
          },
          {
            "$ref": "#/components/schemas/SetGitLabCredentials"
          },
          {
            "$ref": "#/components/schemas/SetCodeCommitCredentials"
          },
          {
            "$ref": "#/components/schemas/SetStoryblokCredentials"
          },
          {
            "$ref": "#/components/schemas/SetZendeskCredentials"
          },
          {
            "$ref": "#/components/schemas/SetCrispHelpdeskCredentials"
          }
        ]
      },
      "SetTokenCredentials": {
        "type": "object",
        "additionalProperties": false,
        "description": "Request body to replace the access token of a manual authentication. Azure DevOps and Bitbucket store it without a remote check; Contentful, HubSpot and Stripo validate it with the provider first.",
        "properties": {
          "provider": {
            "type": "string",
            "description": "Selects this shape of the body.",
            "enum": [
              "AZURE",
              "BITBUCKET",
              "CONTENTFUL",
              "HUBSPOT",
              "STRIPO"
            ],
            "example": "AZURE"
          },
          "access_token": {
            "type": "string",
            "description": "Write-only provider access token; never returned.",
            "example": "provider-token",
            "maxLength": 8192,
            "minLength": 1
          }
        },
        "required": [
          "access_token",
          "provider"
        ]
      },
      "SetGitLabCredentials": {
        "type": "object",
        "additionalProperties": false,
        "description": "Request body to replace the credentials of a manual GitLab authentication. Stored without a remote check.",
        "properties": {
          "provider": {
            "type": "string",
            "description": "Selects this shape of the body.",
            "enum": [
              "GITLAB"
            ],
            "example": "GITLAB"
          },
          "access_token": {
            "type": "string",
            "description": "Write-only provider credential. Saved without a remote validity check.",
            "example": "provider-credential",
            "maxLength": 8192,
            "minLength": 1
          },
          "is_self_hosted": {
            "type": "boolean",
            "description": "Whether to use the existing self-hosted GitLab configuration.",
            "example": false
          },
          "provider_url": {
            "type": [
              "string",
              "null"
            ],
            "description": "Provider base URL, required for self-hosted GitLab. Otherwise ignored, preserving the existing hosted default.",
            "example": "https://gitlab.example.com",
            "maxLength": 4096,
            "minLength": 0
          }
        },
        "required": [
          "access_token",
          "is_self_hosted",
          "provider"
        ]
      },
      "SetCodeCommitCredentials": {
        "type": "object",
        "additionalProperties": false,
        "description": "Request body to replace the credentials of a manual AWS CodeCommit authentication. Stored without a remote check.",
        "properties": {
          "provider": {
            "type": "string",
            "description": "Selects this shape of the body.",
            "enum": [
              "AWS_CODE_COMMIT"
            ],
            "example": "AWS_CODE_COMMIT"
          },
          "access_token": {
            "type": "string",
            "description": "Write-only provider credential. Saved without a remote validity check. Format: accessKey:secretKey or accessKey:secretKey:sessionToken.",
            "example": "provider-credential",
            "maxLength": 8192,
            "minLength": 1
          },
          "region": {
            "type": "string",
            "description": "Existing CodeCommit region setting.",
            "example": "us-east-1",
            "maxLength": 255,
            "minLength": 1
          }
        },
        "required": [
          "access_token",
          "provider",
          "region"
        ]
      },
      "SetStoryblokCredentials": {
        "type": "object",
        "additionalProperties": false,
        "description": "Request body to replace the credentials of a manual Storyblok authentication. Name and identity are preserved; the token is validated and never returned.",
        "properties": {
          "provider": {
            "type": "string",
            "description": "Selects this shape of the body.",
            "enum": [
              "STORYBLOK"
            ],
            "example": "STORYBLOK"
          },
          "region": {
            "$ref": "#/components/schemas/StoryblokRegion",
            "description": "Existing Storyblok hosting region.",
            "example": "EUROPE"
          },
          "access_token": {
            "type": "string",
            "description": "Provider access token. Validated and stored through the existing encrypted credential path; never returned.",
            "example": "provider-token",
            "maxLength": 8192,
            "minLength": 1
          }
        },
        "required": [
          "access_token",
          "provider",
          "region"
        ]
      },
      "StoryblokRegion": {
        "type": "string",
        "description": "Existing Storyblok hosting regions.",
        "enum": [
          "EUROPE",
          "UNITED_STATES",
          "CANADA",
          "AUSTRALIA",
          "CHINA"
        ]
      },
      "SetZendeskCredentials": {
        "type": "object",
        "additionalProperties": false,
        "description": "Request body to replace the credentials of a manual Zendesk authentication. Name and identity are preserved; the credentials are validated and never returned.",
        "properties": {
          "provider": {
            "type": "string",
            "description": "Selects this shape of the body.",
            "enum": [
              "ZENDESK"
            ],
            "example": "ZENDESK"
          },
          "provider_url": {
            "type": "string",
            "description": "Canonical HTTPS Zendesk tenant origin. Custom aliases, paths, credentials and ports are not accepted by this V2 credential route.",
            "example": "https://example.zendesk.com",
            "maxLength": 2048,
            "minLength": 1,
            "pattern": "^https://[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.zendesk\\.com/?$"
          },
          "username": {
            "type": "string",
            "description": "Existing Zendesk API username; use the same value as the integration setup.",
            "example": "agent@example.com",
            "maxLength": 255,
            "minLength": 1
          },
          "access_token": {
            "type": "string",
            "description": "Provider access token. Validated and stored through the existing encrypted credential path; never returned.",
            "example": "provider-token",
            "maxLength": 8192,
            "minLength": 1
          }
        },
        "required": [
          "access_token",
          "provider",
          "provider_url",
          "username"
        ]
      },
      "SetCrispHelpdeskCredentials": {
        "type": "object",
        "additionalProperties": false,
        "description": "Request body to replace the credentials of a manual Crisp Helpdesk authentication. Name and identity are preserved; the credentials are validated and never returned.",
        "properties": {
          "provider": {
            "type": "string",
            "description": "Selects this shape of the body.",
            "enum": [
              "CRISP_HELPDESK"
            ],
            "example": "CRISP_HELPDESK"
          },
          "identifier": {
            "type": "string",
            "description": "Crisp plugin identifier.",
            "example": "plugin-identifier",
            "maxLength": 255,
            "minLength": 1
          },
          "key": {
            "type": "string",
            "description": "Crisp plugin key. Never returned.",
            "example": "provider-key",
            "maxLength": 8192,
            "minLength": 1
          },
          "website_key": {
            "type": "string",
            "description": "External Crisp website key, not a LingoHub identity.",
            "example": "website-key",
            "maxLength": 255,
            "minLength": 1
          }
        },
        "required": [
          "identifier",
          "key",
          "provider",
          "website_key"
        ]
      },
      "IntegrationAuthentication": {
        "type": "object",
        "description": "Stored authentication of a Git host or content system, without credentials or external account and installation identifiers. Its status is the stored lifecycle, not a live provider-access or token-validity check.",
        "example": {
          "object_type": "INTEGRATION_AUTHENTICATION",
          "id": "iau_0197c8f2-5a6b-7cde-8f12-3456789abcde",
          "name": "Company GitHub installation",
          "provider": "GITHUB",
          "type": "INSTALLATION",
          "status": "ACTIVE",
          "is_self_hosted": false,
          "provider_origin": "https://github.com",
          "provider_region": null,
          "created_at": "2025-01-15T10:30:00.123Z",
          "updated_at": "2025-06-20T14:45:00.123Z"
        },
        "properties": {
          "object_type": {
            "type": "string",
            "description": "Always `INTEGRATION_AUTHENTICATION`.",
            "enum": [
              "INTEGRATION_AUTHENTICATION"
            ],
            "example": "INTEGRATION_AUTHENTICATION"
          },
          "id": {
            "type": "string",
            "description": "Public identity of the stored authentication.",
            "example": "iau_0197c8f2-5a6b-7cde-8f12-3456789abcde",
            "minLength": 1,
            "pattern": "^iau_[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": "Stored display name.",
            "example": "Company GitHub installation"
          },
          "provider": {
            "$ref": "#/components/schemas/IntegrationProvider",
            "description": "Provider.",
            "example": "GITHUB"
          },
          "type": {
            "$ref": "#/components/schemas/IntegrationAuthenticationType",
            "description": "How this authentication was provisioned.",
            "example": "INSTALLATION"
          },
          "status": {
            "$ref": "#/components/schemas/IntegrationAuthenticationStatus",
            "description": "Stored lifecycle, not live connectivity.",
            "example": "ACTIVE"
          },
          "is_self_hosted": {
            "type": "boolean",
            "description": "Whether the authentication uses a self-hosted provider.",
            "example": false
          },
          "provider_origin": {
            "type": [
              "string",
              "null"
            ],
            "description": "HTTP(S) scheme, host and optional port of a Git host. Null for CodeCommit, content systems and invalid stored URLs; never credentials, path, query or fragment.",
            "example": "https://github.com"
          },
          "provider_region": {
            "type": [
              "string",
              "null"
            ],
            "description": "Stored CodeCommit region; null for other providers or invalid regions.",
            "example": "us-east-1"
          },
          "created_at": {
            "type": "string",
            "format": "date-time",
            "description": "Creation time of the stored authentication.",
            "example": "2025-01-15T10:30:00.123Z"
          },
          "updated_at": {
            "type": "string",
            "format": "date-time",
            "description": "Metadata update time of the stored authentication.",
            "example": "2025-06-20T14:45:00.123Z"
          }
        },
        "required": [
          "created_at",
          "id",
          "is_self_hosted",
          "name",
          "object_type",
          "provider",
          "provider_origin",
          "provider_region",
          "status",
          "type",
          "updated_at"
        ]
      },
      "IntegrationProvider": {
        "type": "string",
        "description": "Provider of a stored integration authentication: a Git host or a content system.",
        "enum": [
          "GITHUB",
          "BITBUCKET",
          "GITLAB",
          "AZURE",
          "AWS_CODE_COMMIT",
          "STORYBLOK",
          "CONTENTFUL",
          "ZENDESK",
          "HUBSPOT",
          "STRIPO",
          "CRISP_HELPDESK"
        ]
      },
      "IntegrationAuthenticationType": {
        "type": "string",
        "description": "`INSTALLATION` for the LingoHub GitHub App, `OAUTH` when signed in through the provider, `MANUAL` for a token or keys entered by hand.",
        "enum": [
          "MANUAL",
          "OAUTH",
          "INSTALLATION"
        ]
      },
      "IntegrationAuthenticationStatus": {
        "type": "string",
        "description": "`SUSPENDED` or `REVOKED` when the GitHub App was suspended or uninstalled on GitHub; other connections are always `ACTIVE`.",
        "enum": [
          "ACTIVE",
          "SUSPENDED",
          "REVOKED"
        ]
      },
      "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"
        ]
      },
      "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"
        ]
      }
    },
    "headers": {
      "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"
      }
    }
  }
}
````
