# Create a key

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

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

Creates a key after the last key of its group in the file, with a new segment and its source text. The stack's automations set the statuses and labels, as for a key created in the editor; without a matching automation the texts start as NEW. The new key is never linked to an existing segment with the same text. Single-language CSV files only take complete rows; import the file instead. Requires stack-level segment and key management and resource view permissions.

## Parameters

| Parameter | In | Required | Type | Description |
| --- | --- | --- | --- | --- |
| `resourceId` | path | yes | string | Public identifier of the file. |
| `Idempotency-Key` | header | no | string | Optional unique key for best-effort POST retry protection. The key is reserved, the request runs with ordinary service transactions, then the successful response is retained separately for 24 hours by default. There is n… |

## Example request

```sh
curl --request POST \
  --url https://api.lingohub.com/v2/resources/RESOURCE_ID/keys \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
  "key": "navigation.sign_in",
  "group_key": "checkout",
  "is_plural": false,
  "source_variants": [
    {
      "device": "OTHER",
      "plural_form": "OTHER",
      "content": "Sign in"
    }
  ],
  "label_ids": [
    "la_0197c8f2-5a6b-7cde-8f12-3456789abcde"
  ]
}'
```

## Responses

- `201`: The created key.
- `400`: 
- `401`: 
- `403`: 
- `404`: 
- `409`: `conflict`: the file is a single-language CSV file, which only takes complete rows (import it instead); the file's format or project doesn't take keys created by hand; another change to the file's keys is in progress (re…
- `413`: 
- `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": "Keys",
      "description": "List and manage the keys of a file. A key is where a segment appears in a file; the segment holds its texts."
    }
  ],
  "paths": {
    "/v2/resources/{resourceId}/keys": {
      "post": {
        "tags": [
          "Keys"
        ],
        "summary": "Create a key",
        "description": "Creates a key after the last key of its group in the file, with a new segment and its source text. The stack's automations set the statuses and labels, as for a key created in the editor; without a matching automation the texts start as NEW. The new key is never linked to an existing segment with the same text. Single-language CSV files only take complete rows; import the file instead. Requires stack-level segment and key management and resource view permissions.",
        "operationId": "createKey",
        "parameters": [
          {
            "name": "resourceId",
            "in": "path",
            "description": "Public identifier of the file.",
            "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}$"
            }
          },
          {
            "name": "Idempotency-Key",
            "in": "header",
            "description": "Optional unique key for best-effort POST retry protection. The key is reserved, the request runs with ordinary service transactions, then the successful response is retained separately for 24 hours by default. There is no request-wide transaction or atomic commit between the operation and its replay result. A matching cached response is replayed verbatim with `Idempotent-Replayed: true`. Loss or expiry of the retained response can remove protection and allow re-execution. Uploads and chunked bodies are covered; multipart boundaries and JSON property order may differ. Retries still pass validation and current authorization; a later 403/404 does not undo the original operation. A changed payload returns 422 `idempotency_key_mismatch`. A recent active reservation returns 409 `idempotency_key_in_use` with `Retry-After`. A retry with an unresolved key, including an unfinished reservation older than 5 minutes, returns 409 `idempotency_outcome_unknown` without `Retry-After`. This timeout does not release the reservation or permit re-execution while it is retained. Inspect the affected resource before starting a new operation; do not blindly reuse an unresolved key after expiry. A 4xx rejection releases the reservation, allowing the same key to be retried after correcting the cause. A 5xx or interruption after execution starts leaves it unresolved. An unavailable reservation store returns 503 before execution; an oversized request returns 413. Cache-save failure or a response over the cache limit preserves the original success status, headers and body; only future retries become unresolved. When idempotency is explicitly disabled by server configuration, the header is ignored and requests execute normally without retry protection. Use a new unique key for each intended operation.",
            "required": false,
            "schema": {
              "type": "string",
              "maxLength": 255,
              "minLength": 1
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateKey"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "description": "The created key.",
            "headers": {
              "RateLimit": {
                "$ref": "#/components/headers/RateLimit"
              },
              "Idempotent-Replayed": {
                "$ref": "#/components/headers/Idempotent-Replayed"
              },
              "ETag": {
                "$ref": "#/components/headers/ETag"
              },
              "RateLimit-Policy": {
                "$ref": "#/components/headers/RateLimit-Policy"
              },
              "Location": {
                "description": "URL of the created key.",
                "style": "simple",
                "schema": {
                  "type": "string"
                }
              }
            },
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Key"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "description": "`conflict`: the file is a single-language CSV file, which only takes complete rows (import it instead); the file's format or project doesn't take keys created by hand; another change to the file's keys is in progress (retry); or an automation that runs on new keys adds a label that was deleted. `already_exists`: the file has the key. `branch_not_ready`: the branch hasn't finished initializing. An unresolved request returns `idempotency_outcome_unknown` without Retry-After; inspect the affected resource before starting a new operation. A recent request with the same Idempotency-Key is still being processed (`idempotency_key_in_use`); retry after the number of seconds in the `Retry-After` header.",
            "headers": {
              "Retry-After": {
                "description": "Seconds to wait for an in-progress keyed request; absent for other conflicts.",
                "schema": {
                  "type": "integer",
                  "format": "int32"
                }
              },
              "RateLimit": {
                "$ref": "#/components/headers/RateLimit"
              },
              "RateLimit-Policy": {
                "$ref": "#/components/headers/RateLimit-Policy"
              }
            },
            "content": {
              "application/problem+json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "413": {
            "$ref": "#/components/responses/ContentTooLarge"
          },
          "422": {
            "$ref": "#/components/responses/UnprocessableContent"
          },
          "429": {
            "$ref": "#/components/responses/TooManyRequests"
          },
          "500": {
            "$ref": "#/components/responses/InternalServerError"
          },
          "503": {
            "$ref": "#/components/responses/ServiceUnavailable"
          }
        },
        "security": [
          {
            "bearerAuth": []
          }
        ]
      }
    }
  },
  "components": {
    "schemas": {
      "CreateKey": {
        "type": "object",
        "additionalProperties": false,
        "description": "Request body to create a key in a file, with a new segment and its source text.",
        "properties": {
          "key": {
            "type": "string",
            "description": "The full key, as the Key object shows it: nested keys join their parts with dots and put a part that is empty or contains a dot, a double quote or a backslash in double quotes, escaping quotes and backslashes with a backslash. The project's key normalization applies. At most 128 parts and 49,999 characters as stored, with the group.",
            "example": "navigation.sign_in",
            "maxLength": 100000,
            "minLength": 1
          },
          "group_key": {
            "type": [
              "string",
              "null"
            ],
            "description": "The group of the key, in formats with one group only (`key_type` REQUIRED_KEY_WITH_GROUP: PO, Qt TS, INI, Twine). Leaving it out or null creates the key without a group.",
            "example": "checkout",
            "maxLength": 50000,
            "minLength": 0
          },
          "is_plural": {
            "type": [
              "boolean",
              "null"
            ],
            "default": false,
            "description": "Whether the segment has plural forms. The file's format must allow it. Defaults to false.",
            "example": false
          },
          "source_variants": {
            "type": [
              "array",
              "null"
            ],
            "description": "The source text, one variant per device and plural form, in this order. Leaving it out, null or `[]` creates the key with an empty source text. At most 1,048,576 characters in total.",
            "example": [
              {
                "device": "OTHER",
                "plural_form": "OTHER",
                "content": "Sign in"
              }
            ],
            "items": {
              "$ref": "#/components/schemas/WriteTextVariant"
            },
            "maxItems": 1000,
            "minItems": 0
          },
          "label_ids": {
            "type": [
              "array",
              "null"
            ],
            "description": "Labels of the workspace to add to the new segment. The stack's automations can add more.",
            "example": [
              "la_0197c8f2-5a6b-7cde-8f12-3456789abcde"
            ],
            "items": {
              "type": "string",
              "example": "la_0197c8f2-5a6b-7cde-8f12-3456789abcde",
              "pattern": "^la_[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}$"
            },
            "maxItems": 150,
            "minItems": 0,
            "uniqueItems": true
          }
        },
        "required": [
          "key"
        ]
      },
      "WriteTextVariant": {
        "type": "object",
        "additionalProperties": false,
        "description": "One variant of a text: its content for a device and a plural form. The variants of a text keep the order they are sent in.",
        "properties": {
          "device": {
            "$ref": "#/components/schemas/VariantDevice",
            "default": "OTHER",
            "description": "Device the variant is for. Defaults to OTHER.",
            "example": "OTHER"
          },
          "plural_form": {
            "$ref": "#/components/schemas/VariantPluralForm",
            "default": "OTHER",
            "description": "Plural form of the variant; a segment without plural forms takes OTHER only. Defaults to OTHER.",
            "example": "OTHER"
          },
          "content": {
            "type": "string",
            "description": "The text, with its placeholders and markup. A variant that is still empty after the project's automations is removed. At most 51,999 characters.",
            "example": "Sign in",
            "maxLength": 51999
          }
        },
        "required": [
          "content"
        ]
      },
      "VariantDevice": {
        "type": "string",
        "description": "Device of a text variant.",
        "enum": [
          "PHONE",
          "MUSIC_PLAYER",
          "TABLET",
          "WATCH",
          "TV",
          "GLASSES",
          "PC",
          "OTHER"
        ]
      },
      "VariantPluralForm": {
        "type": "string",
        "description": "Plural form of a text variant.",
        "enum": [
          "ZERO",
          "ONE",
          "TWO",
          "FEW",
          "MANY",
          "OTHER"
        ]
      },
      "Key": {
        "type": "object",
        "description": "Where a segment appears in a file: one entry of the file, with its key and position. `segment_id` leads to the segment and its texts; renaming or removing a key leaves the segment and its other keys unchanged.",
        "properties": {
          "object_type": {
            "type": "string",
            "description": "Always `KEY`.",
            "enum": [
              "KEY"
            ],
            "example": "KEY"
          },
          "id": {
            "type": "string",
            "description": "Public identifier of this key.",
            "example": "ress_0197c8f2-5a6b-7cde-8f12-3456789abcde",
            "minLength": 1,
            "pattern": "^ress_[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}$"
          },
          "segment_id": {
            "type": "string",
            "description": "Public identifier of the segment that holds the texts of this key.",
            "example": "seg_0197c8f2-5a6b-7cde-8f12-3456789abcde",
            "pattern": "^seg_[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}$"
          },
          "resource_id": {
            "type": "string",
            "description": "Public identifier of the file containing this key.",
            "example": "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}$"
          },
          "branch_id": {
            "type": "string",
            "description": "Public identifier of the branch containing the file.",
            "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}$"
          },
          "project_id": {
            "type": "string",
            "description": "Public identifier of the project containing the file.",
            "example": "pr_0197c8f2-5a6b-7cde-8f12-3456789abcde",
            "pattern": "^pr_[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}$"
          },
          "key": {
            "type": "string",
            "description": "The key, exactly as createKey and updateKey take it. In nested formats (`key_type` REQUIRED_KEY_WITH_MULTIPLE_GROUPS) its parts are joined by dots, and a part that is empty or contains a dot, a double quote or a backslash is in double quotes, with quotes and backslashes escaped by a backslash. In formats with one group the group is in `group_key`. Entries a format groups on its own, such as the cells of a single-language CSV row (`cell_B3`), show their own key.",
            "example": "navigation.sign_in"
          },
          "group_key": {
            "type": [
              "string",
              "null"
            ],
            "description": "The group of the key in formats with one group (`key_type` REQUIRED_KEY_WITH_GROUP: PO, Qt TS, INI, Twine). Null otherwise, and for a key without a group.",
            "example": null
          },
          "position": {
            "type": "integer",
            "format": "int32",
            "description": "Position of the key within its group of the file, starting at 1. Keys are listed in file order.",
            "example": 1
          },
          "key_type": {
            "description": "How keys of the file's format are written: OPTIONAL_KEY (TXT, Markdown, HTML: the key is optional), REQUIRED_KEY (flat keys), REQUIRED_KEY_WITH_GROUP (a key and its `group_key`), REQUIRED_KEY_WITH_MULTIPLE_GROUPS (nested keys, their parts joined by dots). Null for a file without a format.",
            "example": "REQUIRED_KEY_WITH_MULTIPLE_GROUPS",
            "oneOf": [
              {
                "$ref": "#/components/schemas/KeyType"
              },
              {
                "type": "null"
              }
            ]
          },
          "is_rename_allowed": {
            "type": "boolean",
            "description": "Whether the project and the file's format allow renaming the key (updateKey). Single-language CSV, document, subtitle, Storyblok and integration projects don't. API permissions are checked separately.",
            "example": true
          },
          "is_delete_allowed": {
            "type": "boolean",
            "description": "Whether the project and the file's format allow removing the key (deleteKey). Single-language CSV, document, subtitle, Storyblok and integration projects don't. API permissions are checked separately.",
            "example": true
          },
          "created_at": {
            "type": "string",
            "format": "date-time",
            "description": "Timestamp when the key was created.",
            "example": "2026-09-29T00:00:00.123Z"
          },
          "updated_at": {
            "type": "string",
            "format": "date-time",
            "description": "Timestamp when the key, its position or its file last changed.",
            "example": "2026-09-29T00:00:00.123Z"
          }
        },
        "required": [
          "branch_id",
          "created_at",
          "group_key",
          "id",
          "is_delete_allowed",
          "is_rename_allowed",
          "key",
          "key_type",
          "object_type",
          "position",
          "project_id",
          "resource_id",
          "segment_id",
          "updated_at"
        ]
      },
      "KeyType": {
        "type": "string",
        "description": "How the keys of a file's format are written: OPTIONAL_KEY (TXT, Markdown, HTML: the key is optional), REQUIRED_KEY (flat keys), REQUIRED_KEY_WITH_GROUP (a key and its `group_key`: PO, Qt TS, INI, Twine), REQUIRED_KEY_WITH_MULTIPLE_GROUPS (nested keys, their parts joined by dots).",
        "enum": [
          "OPTIONAL_KEY",
          "REQUIRED_KEY",
          "REQUIRED_KEY_WITH_GROUP",
          "REQUIRED_KEY_WITH_MULTIPLE_GROUPS"
        ]
      },
      "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"
        }
      },
      "Idempotent-Replayed": {
        "description": "True when the original successful result was replayed for this key.",
        "schema": {
          "type": "boolean"
        }
      },
      "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-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"
            }
          }
        }
      },
      "ContentTooLarge": {
        "description": "The request exceeds the body or upload limit; no operation was performed.",
        "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"
      }
    }
  }
}
````
