# Retrieve a resource

`GET https://api.lingohub.com/v2/resources/{resourceId}`

LingoHub API V2 (Beta) · [Resources](https://developers.lingohub.com/reference/v2/operations/tags/resources.md) · operation `getResource`

Returns one file or folder with its per-language counts and content versions. A resource the key can't see returns 404, the same as one that doesn't exist. Requires project-level resource view permission.

## Parameters

| Parameter | In | Required | Type | Description |
| --- | --- | --- | --- | --- |
| `resourceId` | path | yes | string | Unique identifier of the resource. |

## Example request

```sh
curl --request GET \
  --url https://api.lingohub.com/v2/resources/rc_0197c8f2-5a6b-7cde-8f12-3456789abcde \
  --header 'Authorization: Bearer YOUR_API_KEY'
```

## Responses

- `200`: Resource retrieved successfully.
- `400`: 
- `401`: 
- `403`: 
- `404`: 
- `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": "Resources",
      "description": "List and manage the resource files of a project branch, with their format, path and translation status per language."
    }
  ],
  "paths": {
    "/v2/resources/{resourceId}": {
      "get": {
        "tags": [
          "Resources"
        ],
        "summary": "Retrieve a resource",
        "description": "Returns one file or folder with its per-language counts and content versions. A resource the key can't see returns 404, the same as one that doesn't exist. Requires project-level resource view permission.",
        "operationId": "getResource",
        "parameters": [
          {
            "name": "resourceId",
            "in": "path",
            "description": "Unique identifier of the resource.",
            "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 a resource container, a valid value would be : rc_0197c8f2-5a6b-7cde-8f12-3456789abcde",
              "pattern": "^rc_[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}$"
            },
            "example": "rc_0197c8f2-5a6b-7cde-8f12-3456789abcde"
          }
        ],
        "responses": {
          "200": {
            "description": "Resource retrieved successfully.",
            "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/Resource"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "429": {
            "$ref": "#/components/responses/TooManyRequests"
          },
          "500": {
            "$ref": "#/components/responses/InternalServerError"
          },
          "503": {
            "$ref": "#/components/responses/ServiceUnavailable"
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    }
  },
  "components": {
    "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"
        }
      }
    },
    "schemas": {
      "Resource": {
        "type": "object",
        "description": "A resource file or folder (container) within a project branch, exposing its format and path metadata and per-language status counts.",
        "properties": {
          "object_type": {
            "type": "string",
            "description": "Always `RESOURCE`.",
            "enum": [
              "RESOURCE"
            ],
            "example": "RESOURCE"
          },
          "id": {
            "type": "string",
            "description": "Unique identifier of the resource.",
            "example": "rc_0197c8f2-5a6b-7cde-8f12-3456789abcde",
            "minLength": 1,
            "pattern": "^rc_[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}$"
          },
          "branch_id": {
            "type": "string",
            "description": "Unique identifier of the project branch this resource belongs to.",
            "example": "prb_0197c8f2-5a6b-7cde-8f12-3456789abcde",
            "pattern": "^prb_[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 resource (the last path segment).",
            "example": "strings.xml"
          },
          "path": {
            "type": "string",
            "description": "Full path within the branch. File paths contain language placeholders that are resolved for each exported language.",
            "example": "app/src/main/res/%{locale}/strings.xml"
          },
          "type": {
            "$ref": "#/components/schemas/ResourceType",
            "description": "FILE holds keys; FOLDER groups other resources.",
            "example": "FILE"
          },
          "format": {
            "description": "File format of the resource. Null for folders.",
            "example": "ANDROID_XML",
            "oneOf": [
              {
                "$ref": "#/components/schemas/ResourceFormat"
              },
              {
                "type": "null"
              }
            ]
          },
          "language_code_separator": {
            "type": "string",
            "description": "Separator between the file name and the language code (defaults to \"_\").",
            "example": "-",
            "maxLength": 256,
            "minLength": 0
          },
          "content_version": {
            "type": [
              "integer",
              "null"
            ],
            "format": "int64",
            "description": "Version of this resource's exported content. A file's number moves whenever any of its languages moves and when a language is\nadded to or removed from it; a folder's number combines the numbers of the files below it and moves whenever any of them does. It increases whenever anything changes that could alter an export of the file (its segments, their texts and\nstatuses, keys, order, the file itself, the languages, the export settings, the branch). Compare it with the content_version of\nyour last export entry for the same file, language and export settings, and export again only when it moved. It tracks the\ntranslatable data: a LingoHub release can still change how a format is rendered, and ARB embeds a generation timestamp -\nre-export after a release when byte identity matters. Null for a file\nwithout languages.",
            "example": 42
          },
          "language_status_counts": {
            "type": "array",
            "description": "Per-language segment metrics, grouped by workflow stage and status.",
            "example": [
              {
                "language_code": "de-DE",
                "content_version": 42,
                "stages": [
                  {
                    "stage": "NEEDS_REVIEW",
                    "counts": {
                      "segment_count": 42,
                      "word_count": 318,
                      "source_word_count": 305,
                      "character_count": 1890,
                      "suggestion_count": 7
                    },
                    "statuses": [
                      {
                        "status": "TRANSLATED",
                        "counts": {
                          "segment_count": 42,
                          "word_count": 318,
                          "source_word_count": 305,
                          "character_count": 1890,
                          "suggestion_count": 7
                        }
                      }
                    ]
                  }
                ]
              }
            ],
            "items": {
              "$ref": "#/components/schemas/ResourceLanguageStatusCount"
            }
          },
          "created_at": {
            "type": "string",
            "format": "date-time",
            "description": "When the resource file or folder was created.",
            "example": "2026-01-01T10:40:00.123Z"
          },
          "updated_at": {
            "type": "string",
            "format": "date-time",
            "description": "Stored resource metadata update time. Text and other export-input changes are tracked by content_version, not this timestamp.",
            "example": "2026-01-02T10:40:00.123Z"
          }
        },
        "required": [
          "branch_id",
          "content_version",
          "created_at",
          "format",
          "id",
          "language_code_separator",
          "language_status_counts",
          "name",
          "object_type",
          "path",
          "type",
          "updated_at"
        ]
      },
      "ResourceType": {
        "type": "string",
        "description": "What a resource is:\n  - FILE: holds keys (a file, or a page, article or entry of a connected tool)\n  - FOLDER: groups other resources and holds no keys\n",
        "enum": [
          "FILE",
          "FOLDER"
        ]
      },
      "ResourceFormat": {
        "type": "string",
        "description": "The file format of a resource. Determines how the file is parsed on import and rendered on export. Folders have no format.",
        "enum": [
          "ANDROID_XML",
          "IOS_STRINGS",
          "IOS_STRINGSDICT",
          "IOS_STRINGS_CATALOG",
          "STANDARD_PROPERTIES",
          "GETTEXT_PO",
          "WINDOWS_RESX",
          "QT_LINGUIST_TS",
          "DEFINE_PHP",
          "STANDARD_INI",
          "STANDARD_ARB",
          "RAILS_YAML",
          "SYMFONY_YAML",
          "STANDARD_JSON",
          "STORYBLOK_JSON",
          "ANGULAR_TRANSLATE_JSON",
          "CHROME_I18N_JSON",
          "GO_I18N_JSON",
          "I18NEXT_JSON",
          "REACT_INTL_JSON",
          "STANDARD_CSV",
          "SINGLE_LANGUAGE_CSV",
          "KEY_VALUE_CSV",
          "STANDARD_XLIFF",
          "STANDARD_XLIFF_2",
          "STANDARD_TXT",
          "TWINE_TXT",
          "STANDARD_MARKDOWN",
          "STANDARD_HTML",
          "FIGMA",
          "ZENDESK",
          "STORYBLOK",
          "CONTENTFUL",
          "SUBTITLE_SRT",
          "SUBTITLE_VTT",
          "HUBSPOT",
          "STRIPO",
          "CRISP_HELPDESK",
          "DOCX",
          "PPTX",
          "ODT",
          "ODP",
          "VUE_I18N_JSON"
        ]
      },
      "ResourceLanguageStatusCount": {
        "type": "object",
        "description": "Per-language segment metrics for a resource, grouped by workflow `stage` and broken down by text status within each stage.",
        "properties": {
          "language_code": {
            "type": "string",
            "description": "The language code these metrics belong to.",
            "example": "de-DE"
          },
          "content_version": {
            "type": [
              "integer",
              "null"
            ],
            "format": "int64",
            "description": "Version of this language of the file. It increases whenever anything changes that could alter the export of this language (its texts and statuses, the source texts, the file's segments and keys, the languages, the export settings).",
            "example": 42
          },
          "stages": {
            "type": "array",
            "description": "Per-stage metrics, ordered by workflow stage (NOT_READY → NEEDS_EDIT → NEEDS_REVIEW → DONE).",
            "example": [
              {
                "stage": "NEEDS_REVIEW",
                "counts": {
                  "segment_count": 42,
                  "word_count": 318,
                  "source_word_count": 305,
                  "character_count": 1890,
                  "suggestion_count": 7
                },
                "statuses": [
                  {
                    "status": "TRANSLATED",
                    "counts": {
                      "segment_count": 42,
                      "word_count": 318,
                      "source_word_count": 305,
                      "character_count": 1890,
                      "suggestion_count": 7
                    }
                  }
                ]
              }
            ],
            "items": {
              "$ref": "#/components/schemas/ResourceStageStatusCount"
            }
          }
        },
        "required": [
          "content_version",
          "language_code",
          "stages"
        ]
      },
      "ResourceStageStatusCount": {
        "type": "object",
        "description": "Segment metrics for a single workflow stage within a language: the `counts` are the stage total across its statuses, and `statuses` lists the per-status breakdown.",
        "properties": {
          "stage": {
            "$ref": "#/components/schemas/TextStage",
            "description": "The workflow stage these metrics belong to.",
            "example": "NEEDS_REVIEW"
          },
          "counts": {
            "$ref": "#/components/schemas/ResourceCounts",
            "description": "Stage total, summed across all statuses in this stage."
          },
          "statuses": {
            "type": "array",
            "description": "Per-status metric breakdown within this stage, ordered by status.",
            "example": [
              {
                "status": "TRANSLATED",
                "counts": {
                  "segment_count": 42,
                  "word_count": 318,
                  "source_word_count": 305,
                  "character_count": 1890,
                  "suggestion_count": 7
                }
              }
            ],
            "items": {
              "$ref": "#/components/schemas/ResourceStatusCount"
            }
          }
        },
        "required": [
          "counts",
          "stage",
          "statuses"
        ]
      },
      "TextStage": {
        "type": "string",
        "description": "The high-level workflow stage that groups one or more `TextStatus` values:\n  - `NOT_READY` — blocked segments\n  - `NEEDS_EDIT` — new, draft, stale or rejected segments\n  - `NEEDS_REVIEW` — AI-translated, translated, QA-passed or QA-flagged segments\n  - `DONE` — approved or not-translatable segments",
        "enum": [
          "NOT_READY",
          "NEEDS_EDIT",
          "NEEDS_REVIEW",
          "DONE"
        ]
      },
      "ResourceCounts": {
        "type": "object",
        "description": "Aggregated segment metrics, scoped to a single text status or stage.",
        "properties": {
          "segment_count": {
            "type": "integer",
            "format": "int64",
            "description": "Number of segments.",
            "example": 42
          },
          "word_count": {
            "type": "integer",
            "format": "int64",
            "description": "Number of words in the target text.",
            "example": 318
          },
          "source_word_count": {
            "type": "integer",
            "format": "int64",
            "description": "Number of words in the source text.",
            "example": 305
          },
          "character_count": {
            "type": "integer",
            "format": "int64",
            "description": "Number of characters in the target text.",
            "example": 1890
          },
          "suggestion_count": {
            "type": "integer",
            "format": "int64",
            "description": "Number of translation-memory suggestions.",
            "example": 7
          }
        },
        "required": [
          "character_count",
          "segment_count",
          "source_word_count",
          "suggestion_count",
          "word_count"
        ]
      },
      "ResourceStatusCount": {
        "type": "object",
        "description": "Segment metrics for a single text status within a language.",
        "properties": {
          "status": {
            "$ref": "#/components/schemas/TextStatus",
            "description": "The text status these metrics belong to.",
            "example": "TRANSLATED"
          },
          "counts": {
            "$ref": "#/components/schemas/ResourceCounts",
            "description": "Aggregated metrics for this status."
          }
        },
        "required": [
          "counts",
          "status"
        ]
      },
      "TextStatus": {
        "type": "string",
        "description": "The workflow status of texts in a given language. Each status belongs to exactly one `TextStage` (see the `stage` grouping in the status counts).",
        "enum": [
          "BLOCKED",
          "NEW",
          "STALE",
          "REJECTED",
          "DRAFT",
          "AI_TRANSLATED",
          "TRANSLATED",
          "QA_PASSED",
          "QA_FLAGGED",
          "APPROVED",
          "NOT_TRANSLATABLE"
        ]
      },
      "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"
        ]
      }
    },
    "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"
            }
          }
        }
      },
      "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"
      }
    }
  }
}
````
