# Retrieve project settings

`GET https://api.lingohub.com/v2/projects/{projectId}/settings`

LingoHub API V2 (Beta) · [Project Settings](https://developers.lingohub.com/reference/v2/operations/tags/project-settings.md) · operation `getProjectSettings`

Returns all settings of the project: export and import defaults, file-format options, key normalisation, placeholder recognition and, if the project has an integration, the integration settings. Imports and exports use these defaults unless they override them; one that already ran keeps the settings it ran with. Requires project-level settings management permission.

## Parameters

| Parameter | In | Required | Type | Description |
| --- | --- | --- | --- | --- |
| `projectId` | path | yes | string |  |

## Example request

```sh
curl --request GET \
  --url https://api.lingohub.com/v2/projects/PROJECT_ID/settings \
  --header 'Authorization: Bearer YOUR_API_KEY'
```

## Responses

- `200`: The project's settings.
- `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": "Project Settings",
      "description": "Read and change a project's settings: export and import defaults, file-format options, key normalisation, placeholder recognition and integration settings."
    }
  ],
  "paths": {
    "/v2/projects/{projectId}/settings": {
      "get": {
        "tags": [
          "Project Settings"
        ],
        "summary": "Retrieve project settings",
        "description": "Returns all settings of the project: export and import defaults, file-format options, key normalisation, placeholder recognition and, if the project has an integration, the integration settings. Imports and exports use these defaults unless they override them; one that already ran keeps the settings it ran with. Requires project-level settings management permission.",
        "operationId": "getProjectSettings",
        "parameters": [
          {
            "name": "projectId",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "description": "Public id that is created from the type prefix of the corresponding resource and its UUID. I.e : For a project, a valid value would be : 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}$"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "The project's settings.",
            "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/ProjectSettings"
                }
              }
            }
          },
          "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": {
      "ProjectSettings": {
        "type": "object",
        "description": "All settings of a project: export and import defaults, file-format options, key normalisation, placeholder recognition and, if the project has an integration, the integration settings.",
        "properties": {
          "object_type": {
            "type": "string",
            "description": "Always `PROJECT_SETTINGS`.",
            "enum": [
              "PROJECT_SETTINGS"
            ],
            "example": "PROJECT_SETTINGS"
          },
          "id": {
            "type": "string",
            "description": "The project these settings belong to.",
            "example": "pr_0197c8f2-5a6b-7cde-8f12-3456789abcde",
            "minLength": 1,
            "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}$"
          },
          "export": {
            "$ref": "#/components/schemas/ProjectExportSettings",
            "description": "Export defaults."
          },
          "import": {
            "$ref": "#/components/schemas/ProjectImportSettings",
            "description": "Import defaults."
          },
          "format": {
            "description": "File-format options; null for documents and integration projects, which have none.",
            "oneOf": [
              {
                "$ref": "#/components/schemas/ProjectFormatSettings"
              },
              {
                "type": "null"
              }
            ]
          },
          "keys": {
            "$ref": "#/components/schemas/ProjectKeySettings",
            "description": "Key normalisation."
          },
          "placeholders": {
            "$ref": "#/components/schemas/ProjectPlaceholderSettings",
            "description": "Placeholder recognition."
          },
          "integrations": {
            "description": "Integration settings; null when the project has no integration.",
            "oneOf": [
              {
                "$ref": "#/components/schemas/ProjectIntegrationSettings"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "export",
          "format",
          "id",
          "import",
          "integrations",
          "keys",
          "object_type",
          "placeholders"
        ]
      },
      "ProjectExportSettings": {
        "type": "object",
        "description": "Which texts exports write by default. An export can bring its own settings instead.",
        "properties": {
          "source_statuses": {
            "type": [
              "array",
              "null"
            ],
            "description": "The statuses a source text needs to be exported. Null on older projects that never stored a selection.",
            "example": [
              "APPROVED"
            ],
            "items": {
              "$ref": "#/components/schemas/TextStatus"
            }
          },
          "target_statuses": {
            "type": [
              "array",
              "null"
            ],
            "description": "The statuses a target text needs to be exported. Null on older projects that never stored a selection.",
            "example": [
              "APPROVED"
            ],
            "items": {
              "$ref": "#/components/schemas/TextStatus"
            }
          },
          "source_empty_content_handling": {
            "$ref": "#/components/schemas/BlankContentHandling",
            "description": "What an export does with an empty source text.",
            "example": "KEEP"
          },
          "target_empty_content_handling": {
            "$ref": "#/components/schemas/BlankContentHandling",
            "description": "What an export does with an empty target text.",
            "example": "KEEP"
          },
          "is_not_translatable_skipped": {
            "type": "boolean",
            "description": "Whether exports exclude not-translatable entries.",
            "example": false
          },
          "html_encoding": {
            "$ref": "#/components/schemas/HtmlEncoding",
            "description": "How exports write HTML in the formats that support it.",
            "example": "CDATA"
          }
        },
        "required": [
          "html_encoding",
          "is_not_translatable_skipped",
          "source_empty_content_handling",
          "source_statuses",
          "target_empty_content_handling",
          "target_statuses"
        ]
      },
      "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"
        ]
      },
      "BlankContentHandling": {
        "type": "string",
        "description": "What an export does with an empty text: `KEEP` writes the entry with an empty text, `SKIP` leaves the entry out.",
        "enum": [
          "KEEP",
          "SKIP"
        ]
      },
      "HtmlEncoding": {
        "type": "string",
        "description": "HTML handling when a format supports encoding: RAW embeds content unescaped, ESCAPE escapes XML characters, CDATA wraps content.",
        "enum": [
          "RAW",
          "ESCAPE",
          "CDATA"
        ]
      },
      "ProjectImportSettings": {
        "type": "object",
        "description": "What imports do by default with the source texts and the target texts (translations) of a file.",
        "properties": {
          "is_source_creation_enabled": {
            "type": "boolean",
            "description": "Whether imports may create source text entries.",
            "example": true
          },
          "source_text_update_mode": {
            "$ref": "#/components/schemas/TextUpdateMode",
            "description": "When imports may update an existing source text.",
            "example": "ALWAYS"
          },
          "is_source_metadata_update_enabled": {
            "type": "boolean",
            "description": "Whether imports may update source metadata.",
            "example": true
          },
          "is_source_deactivation_enabled": {
            "type": "boolean",
            "description": "Whether imports may deactivate source entries missing from the input.",
            "example": false
          },
          "is_target_creation_enabled": {
            "type": "boolean",
            "description": "Whether imports may create target text entries.",
            "example": true
          },
          "target_text_update_mode": {
            "$ref": "#/components/schemas/TextUpdateMode",
            "description": "When imports may update an existing target text.",
            "example": "ALWAYS"
          },
          "is_target_metadata_update_enabled": {
            "type": "boolean",
            "description": "Whether imports may update target metadata.",
            "example": true
          },
          "is_target_deactivation_enabled": {
            "type": "boolean",
            "description": "Whether imports may deactivate target entries missing from the input.",
            "example": false
          }
        },
        "required": [
          "is_source_creation_enabled",
          "is_source_deactivation_enabled",
          "is_source_metadata_update_enabled",
          "is_target_creation_enabled",
          "is_target_deactivation_enabled",
          "is_target_metadata_update_enabled",
          "source_text_update_mode",
          "target_text_update_mode"
        ]
      },
      "TextUpdateMode": {
        "type": "string",
        "description": "When an import may change an existing text: `ALWAYS` overwrites it, `ONLY_EMPTY` only fills it when it's empty, `NEVER` keeps it.",
        "enum": [
          "ALWAYS",
          "ONLY_EMPTY",
          "NEVER"
        ]
      },
      "ProjectFormatSettings": {
        "type": "object",
        "description": "The options of the project's file format, in sections. Which sections a project needs depends on its type: `general` for every file-based type except DOCUMENT; `csv` for STANDARD_CSV, SINGLE_LANGUAGE_CSV and KEY_VALUE_CSV; `escape` for STANDARD_PROPERTIES and STANDARD_INI; `json` for STANDARD_ARB, STANDARD_JSON, ANGULAR_TRANSLATE_JSON, CHROME_I18N_JSON, GO_I18N_JSON, I18NEXT_JSON, REACT_INTL_JSON and VUE_I18N_JSON; `i18next_json` for I18NEXT_JSON; `xliff` for STANDARD_XLIFF; `properties` for STANDARD_PROPERTIES. A section the type doesn't need has no effect.",
        "properties": {
          "general": {
            "description": "Options every file format uses.",
            "example": {
              "charset": "UTF_8",
              "file_name_languages": "ALL",
              "is_source_used_when_missing": true,
              "comment_languages": "SOURCE",
              "indentation": 2,
              "is_final_newline_enabled": true
            },
            "oneOf": [
              {
                "$ref": "#/components/schemas/GeneralFileFormatConfiguration"
              },
              {
                "type": "null"
              }
            ]
          },
          "csv": {
            "description": "CSV options; required for the CSV project types.",
            "example": {
              "is_import_detection_enabled": true,
              "key_header": "key",
              "description_header": "description",
              "delimiter": ";",
              "quote": "\"",
              "is_status_exported": false
            },
            "oneOf": [
              {
                "$ref": "#/components/schemas/CsvFileFormatConfiguration"
              },
              {
                "type": "null"
              }
            ]
          },
          "escape": {
            "description": "Escaping options; required for STANDARD_PROPERTIES and STANDARD_INI.",
            "example": {
              "is_character_escaping_enabled": true
            },
            "oneOf": [
              {
                "$ref": "#/components/schemas/EscapeFileFormatConfiguration"
              },
              {
                "type": "null"
              }
            ]
          },
          "json": {
            "description": "JSON options; required for the JSON and ARB project types.",
            "example": {
              "is_array_indentation_enabled": false,
              "is_plural_order_alphabetical": false
            },
            "oneOf": [
              {
                "$ref": "#/components/schemas/JsonFileFormatConfiguration"
              },
              {
                "type": "null"
              }
            ]
          },
          "i18next_json": {
            "description": "i18next options; required for I18NEXT_JSON.",
            "example": {
              "version": "VERSION_4",
              "is_base_plural_exported": false
            },
            "oneOf": [
              {
                "$ref": "#/components/schemas/I18nextFileFormatConfiguration"
              },
              {
                "type": "null"
              }
            ]
          },
          "xliff": {
            "description": "XLIFF options; required for STANDARD_XLIFF.",
            "example": {
              "is_resname_identifier": false,
              "is_multi_language": false
            },
            "oneOf": [
              {
                "$ref": "#/components/schemas/XliffFileFormatConfiguration"
              },
              {
                "type": "null"
              }
            ]
          },
          "properties": {
            "description": "Properties options; required for STANDARD_PROPERTIES.",
            "example": {
              "plural_separator": "_"
            },
            "oneOf": [
              {
                "$ref": "#/components/schemas/PropertiesFileFormatConfiguration"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "csv",
          "escape",
          "general",
          "i18next_json",
          "json",
          "properties",
          "xliff"
        ]
      },
      "GeneralFileFormatConfiguration": {
        "type": "object",
        "description": "Options every file format uses.",
        "properties": {
          "charset": {
            "description": "The character encoding of exported files. Null on older projects that never stored one.",
            "example": "UTF_8",
            "oneOf": [
              {
                "$ref": "#/components/schemas/FileCharset"
              },
              {
                "type": "null"
              }
            ]
          },
          "file_name_languages": {
            "description": "Which exported files carry their language code in the file name or path. Null on older projects that never stored one.",
            "example": "ALL",
            "oneOf": [
              {
                "$ref": "#/components/schemas/FileNameLanguages"
              },
              {
                "type": "null"
              }
            ]
          },
          "is_source_used_when_missing": {
            "type": "boolean",
            "description": "Whether to use source content when missing in supported file processing.",
            "example": true
          },
          "comment_languages": {
            "description": "Which exported files carry comments; null: no file does.",
            "example": "SOURCE",
            "oneOf": [
              {
                "$ref": "#/components/schemas/CommentLanguages"
              },
              {
                "type": "null"
              }
            ]
          },
          "indentation": {
            "type": "integer",
            "format": "int32",
            "description": "Spaces per indentation level, in the formats that indent.",
            "example": 2
          },
          "is_final_newline_enabled": {
            "type": "boolean",
            "description": "Whether output ends in a newline.",
            "example": true
          }
        },
        "required": [
          "charset",
          "comment_languages",
          "file_name_languages",
          "indentation",
          "is_final_newline_enabled",
          "is_source_used_when_missing"
        ]
      },
      "FileCharset": {
        "type": "string",
        "description": "The character encoding of exported files.",
        "enum": [
          "UTF_8",
          "UTF_16"
        ]
      },
      "FileNameLanguages": {
        "type": "string",
        "description": "Which exported files carry their language code in the file name or path: `ALL` every file, `TARGETS` only the files of the target languages, `NONE` no file.",
        "enum": [
          "ALL",
          "TARGETS",
          "NONE"
        ]
      },
      "CommentLanguages": {
        "type": "string",
        "description": "Which exported files carry comments: `ALL` every file, `SOURCE` only the file of the source language.",
        "enum": [
          "ALL",
          "SOURCE"
        ]
      },
      "CsvFileFormatConfiguration": {
        "type": "object",
        "description": "How CSV files are read and written.",
        "properties": {
          "is_import_detection_enabled": {
            "type": "boolean",
            "description": "Whether imports may update CSV settings from detected file content.",
            "example": true
          },
          "key_header": {
            "type": [
              "string",
              "null"
            ],
            "description": "The header of the column with the keys. Null: imports take the column headed Title, Key or Id, and exports leave the header empty.",
            "example": "key"
          },
          "description_header": {
            "type": [
              "string",
              "null"
            ],
            "description": "The header of the column with the descriptions. Null: imports take the column headed Description or Comment, and exports leave the header empty.",
            "example": "description"
          },
          "delimiter": {
            "type": [
              "string",
              "null"
            ],
            "description": "The character between the columns. Null on older projects that never stored one.",
            "example": ";"
          },
          "quote": {
            "type": [
              "string",
              "null"
            ],
            "description": "The character that encloses a value. Null on older projects that never stored one.",
            "example": "\""
          },
          "is_status_exported": {
            "type": "boolean",
            "description": "Whether CSV exports include status information.",
            "example": false
          }
        },
        "required": [
          "delimiter",
          "description_header",
          "is_import_detection_enabled",
          "is_status_exported",
          "key_header",
          "quote"
        ]
      },
      "EscapeFileFormatConfiguration": {
        "type": "object",
        "description": "How special characters are written.",
        "properties": {
          "is_character_escaping_enabled": {
            "type": "boolean",
            "description": "Whether file writers escape characters.",
            "example": true
          }
        },
        "required": [
          "is_character_escaping_enabled"
        ]
      },
      "JsonFileFormatConfiguration": {
        "type": "object",
        "description": "How JSON files are laid out.",
        "properties": {
          "is_array_indentation_enabled": {
            "type": "boolean",
            "description": "Whether JSON arrays are indented.",
            "example": false
          },
          "is_plural_order_alphabetical": {
            "type": "boolean",
            "description": "Whether plural forms are ordered alphabetically.",
            "example": false
          }
        },
        "required": [
          "is_array_indentation_enabled",
          "is_plural_order_alphabetical"
        ]
      },
      "I18nextFileFormatConfiguration": {
        "type": "object",
        "description": "How i18next JSON files are read and written.",
        "properties": {
          "version": {
            "description": "The i18next JSON version of the files. Null on older projects that never stored one.",
            "example": "VERSION_4",
            "oneOf": [
              {
                "$ref": "#/components/schemas/I18nextVersion"
              },
              {
                "type": "null"
              }
            ]
          },
          "is_base_plural_exported": {
            "type": "boolean",
            "description": "Whether exports include base plural keys.",
            "example": false
          }
        },
        "required": [
          "is_base_plural_exported",
          "version"
        ]
      },
      "I18nextVersion": {
        "type": "string",
        "description": "The i18next JSON version, which decides how plural keys are named: `VERSION_3` adds `_plural` (or `_0`, `_1`, …), `VERSION_4` adds the plural category, such as `_one` and `_other`.",
        "enum": [
          "VERSION_3",
          "VERSION_4"
        ]
      },
      "XliffFileFormatConfiguration": {
        "type": "object",
        "description": "How XLIFF files identify keys and languages.",
        "properties": {
          "is_resname_identifier": {
            "type": "boolean",
            "description": "Whether resname identifies the segment key.",
            "example": false
          },
          "is_multi_language": {
            "type": "boolean",
            "description": "Whether the XLIFF file carries multiple languages.",
            "example": false
          }
        },
        "required": [
          "is_multi_language",
          "is_resname_identifier"
        ]
      },
      "PropertiesFileFormatConfiguration": {
        "type": "object",
        "description": "How properties files name plural forms.",
        "properties": {
          "plural_separator": {
            "type": [
              "string",
              "null"
            ],
            "description": "The text between a key and its plural form, such as `_` in `apples_one`. Null on older projects that never stored one.",
            "example": "_"
          }
        },
        "required": [
          "plural_separator"
        ]
      },
      "ProjectKeySettings": {
        "type": "object",
        "description": "How the project's keys are normalised.",
        "properties": {
          "normalization_strategy": {
            "description": "How keys are normalised when they are imported, created or renamed. Null on older projects that never stored one.",
            "example": "FORMAT_SPECIFIC",
            "oneOf": [
              {
                "$ref": "#/components/schemas/KeyNormalizationStrategy"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "normalization_strategy"
        ]
      },
      "KeyNormalizationStrategy": {
        "type": "string",
        "description": "How keys are normalised when they are imported, created or renamed: `FORMAT_SPECIFIC` as the file format requires, `ALL` always, `NONE` never. Existing keys aren't renamed.",
        "enum": [
          "FORMAT_SPECIFIC",
          "ALL",
          "NONE"
        ]
      },
      "ProjectPlaceholderSettings": {
        "type": "object",
        "description": "Which placeholders are recognised in the project's texts, for quality checks, LINA and machine translation.",
        "properties": {
          "definitions": {
            "type": [
              "array",
              "null"
            ],
            "description": "The placeholder kinds recognised in texts; the first that matches wins. Empty: none. Null on older projects that never stored a list.",
            "example": [
              "DEFAULT_ICU",
              "DEFAULT_PRINTF"
            ],
            "items": {
              "$ref": "#/components/schemas/PlaceholderDefinition"
            }
          },
          "default_definitions": {
            "type": "array",
            "description": "The placeholder kinds of the project's type; read-only. Send them as `definitions` to go back to the defaults.",
            "example": [
              "DEFAULT_ICU",
              "DEFAULT_PRINTF"
            ],
            "items": {
              "$ref": "#/components/schemas/PlaceholderDefinition"
            }
          },
          "is_default": {
            "type": "boolean",
            "description": "`definitions` equals `default_definitions`; read-only.",
            "example": true
          }
        },
        "required": [
          "default_definitions",
          "definitions",
          "is_default"
        ]
      },
      "PlaceholderDefinition": {
        "type": "string",
        "description": "A supported placeholder-recognition profile. Array order defines recognition precedence; this is not a generic syntax-conversion capability.",
        "enum": [
          "DEFAULT_ICU",
          "DEFAULT_PRINTF",
          "IOS_PRINTF",
          "ANDROID_PRINTF",
          "TWINE_PRINTF",
          "STRINGSDICT_VARIABLE_START_END",
          "STRING_CATALOG_SUBSTITUTION_VARIABLE",
          "RAILS_YAML_START_END",
          "SYMFONY_YAML_START_END",
          "JSON_TEMPLATE_START_END",
          "JSON_REFERENCE_START_END",
          "DEFAULT_REPEAT_CHARACTERS",
          "CHROME_I18N_REPEAT_CHARACTERS",
          "JSON_REPEAT_CHARACTERS",
          "I18_NEXT_REPEAT_CHARACTERS",
          "NQC_REPEAT_CHARACTERS",
          "DOCUMENT_CODE_MARKUP",
          "CHROME_I18N_NUMBERED",
          "QT_LINGUIST_TS_NUMBERED",
          "ANDROID_XLIFF_G",
          "XLIFF_X",
          "XLIFF_BPT",
          "XLIFF_EPT",
          "XLIFF_IT",
          "XLIFF_PH",
          "XLIFF_G",
          "XLIFF_BX",
          "XLIFF_EX"
        ]
      },
      "ProjectIntegrationSettings": {
        "type": "object",
        "description": "What a sync of the project's integration deletes; every integration type has them.",
        "properties": {
          "is_removed_resource_deletion_enabled": {
            "type": "boolean",
            "description": "Whether a Git repository pull deletes files the repository no longer contains. Only Git integrations read this setting; the other integrations always delete resources a sync no longer reports. Enabled by default for Git integrations.",
            "example": true
          },
          "is_removed_language_deletion_enabled": {
            "type": "boolean",
            "description": "Whether a sync deletes languages the integration no longer reports. The source language is never deleted. Only Contentful, HubSpot, Storyblok, Stripo and Zendesk integrations read this setting; Git and Crisp integrations never delete languages. Enabled by default for Contentful, Zendesk and Storyblok integrations.",
            "example": false
          }
        },
        "required": [
          "is_removed_language_deletion_enabled",
          "is_removed_resource_deletion_enabled"
        ]
      },
      "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"
      }
    }
  }
}
````
