---
updatedAt: 2026-08-04T19:21:06.000Z
agentTools:
  projectIndex: https://docs.sensible.so/llms.txt
---

# Get configuration

Get a configuration as stringified JSON.

# OpenAPI definition

```json
{
  "openapi": "3.0.3",
  "servers": [
    {
      "url": "https://api.sensible.so/v0",
      "description": "Production server (uses live data)"
    }
  ],
  "info": {
    "title": "Configuration",
    "version": "0.0.1",
    "description": "Sensible API for configuring document types, SenseML configurations, and reference documents.",
    "license": {
      "name": "Sensible API",
      "url": "https://www.TBD.org/licenses/LICENSE-2.0.html"
    }
  },
  "paths": {
    "/document_types/{type-id}/configurations/{config-name}": {
      "parameters": [
        {
          "$ref": "#/components/parameters/documentTypeId"
        },
        {
          "$ref": "#/components/parameters/configurationName"
        }
      ],
      "get": {
        "operationId": "get-configuration",
        "summary": "Get configuration",
        "description": "Get a configuration as stringified JSON.",
        "tags": [
          "Configuration"
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ConfigurationResponse"
                }
              }
            },
            "description": "The identified configuration"
          },
          "400": {
            "$ref": "#/components/responses/400"
          },
          "401": {
            "$ref": "#/components/responses/401"
          },
          "404": {
            "$ref": "#/components/responses/404"
          },
          "415": {
            "$ref": "#/components/responses/415"
          },
          "500": {
            "$ref": "#/components/responses/500"
          }
        }
      }
    }
  },
  "components": {
    "parameters": {
      "documentTypeId": {
        "name": "type-id",
        "required": true,
        "in": "path",
        "description": "The unique document type identifier in v4 UUID format. Find IDs using the `/document_types` endpoint.",
        "schema": {
          "$ref": "#/components/schemas/UniqueId"
        }
      },
      "configurationName": {
        "name": "config-name",
        "required": true,
        "in": "path",
        "description": "Unique name for a configuration. Find it in the Sensible app or from the `/document_types/{type-id}/configurations` endpoint.",
        "example": "anyco_auto_insurance_quote",
        "schema": {
          "$ref": "#/components/schemas/Name"
        }
      }
    },
    "schemas": {
      "UniqueId": {
        "type": "string",
        "format": "uuid",
        "description": "Unique identifier",
        "example": "3fa85f64-5717-4562-b3fc-2c963f66afa6"
      },
      "Name": {
        "type": "string",
        "pattern": "^[a-z0-9_]+$",
        "minLength": 3,
        "maxLength": 128,
        "description": "User-friendly name",
        "example": "insurance_quote",
        "x-internal-note": "Single shared schema covers config names, document type names, and golden names. You can achieve context-specific examples for the purpose of the API docs ('auto_insurance_quotes_all_carriers', 'anyco_carrier', 'insurance_quote_john_doe' for doc type, config, and document, for example) using allOf wrappers at each usage site, but we're not bothering right now, given codegen is a primary consumer and a single neutral example is sufficient."
      },
      "Date": {
        "type": "string",
        "format": "date-time",
        "description": "ISO 8601 date-time."
      },
      "ConfigurationVersion": {
        "type": "object",
        "properties": {
          "version_id": {
            "type": "string",
            "example": "fdE0LO4d2GftiGvPyeYbgpstRWyLrEdm",
            "x-internal-note": "version_id is returned by the backend but deliberately not documented publicly."
          },
          "datetime": {
            "$ref": "#/components/schemas/Date",
            "description": "The date and time Sensible created this version ID for the config. Sensible creates a new version ID for a config when you: 1. publish a config to an environment in the Sensible app 2. create or edit the configuration through the Sensible API. Publishing or unpublishing an\n   existing configuration version using the Sensible API doesn't trigger the creation of a new version ID."
          },
          "environments": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "example": [
              "production",
              "development"
            ]
          },
          "draft": {
            "type": "boolean",
            "example": false,
            "description": "The version list returned by this endpoint contains a single draft version ID that's used to manage the editor state in the Sensible app. This draft version ID is never published to the development or production environments."
          },
          "note": {
            "type": "string",
            "description": "Optional user-supplied note describing this version."
          },
          "published_by": {
            "type": "string",
            "description": "Display name of whoever published this version: the user's full name (or first name, if that's all that's available), or the account name if the request wasn't tied to an individual user."
          }
        },
        "required": [
          "version_id",
          "datetime",
          "draft"
        ],
        "additionalProperties": false
      },
      "ConfigurationContentType": {
        "type": "string",
        "enum": [
          "application/json",
          "application/yaml",
          "text/csv",
          "text/plain"
        ],
        "description": "Content type of the stringified `configuration`. Defaults to `application/json`."
      },
      "ConfigurationEditor": {
        "type": "number",
        "description": "Numeric code indicating the display mode associated with this configuration in the Sensible app. Indicates whether the SenseML editor displays the configuration as JSON or visually, and whether it displays extraction results as JSON or visually."
      },
      "ConfigurationResponse": {
        "type": "object",
        "properties": {
          "name": {
            "$ref": "#/components/schemas/Name"
          },
          "created": {
            "$ref": "#/components/schemas/Date"
          },
          "configuration": {
            "type": "string",
            "description": "Configuration returned as stringified JSON.",
            "example": "\"{\\r\\n\\t\\\"fingerprint\\\": {\\r\\n\\t\\t\\\"tests\\\": [\\r\\n\\t\\t\\t\\\"anyco\\\",\\r\\n\\t\\t\\t\\\"quoted coverage changes\\\"\\r\\n\\t\\t]\\r\\n\\t},\\r\\n\\t\\\"preprocessors\\\": [{\\r\\n\\t\\t\\\"type\\\": \\\"pageRange\\\",\\r\\n\\t\\t\\\"startPage\\\": 0,\\r\\n\\t\\t\\\"endPage\\\": 2\\r\\n\\t}],\\r\\n\\t\\\"fields\\\": [{\\r\\n\\t\\t\\\"id\\\": \\\"_driver_name_raw\\\",\\r\\n\\t\\t\\\"anchor\\\": \\\"name of driver\\\",\\r\\n\\t\\t\\\"method\\\": {\\r\\n\\t\\t\\t\\\"id\\\": \\\"label\\\",\\r\\n\\t\\t\\t\\\"position\\\": \\\"below\\\"\\r\\n\\t\\t}\\r\\n\\t}],\\r\\n\\t\\\"computed_fields\\\": [{\\r\\n\\t\\t\\t\\\"id\\\": \\\"driver_name_last\\\",\\r\\n\\t\\t\\t\\\"method\\\": {\\r\\n\\t\\t\\t\\t\\\"id\\\": \\\"split\\\",\\r\\n\\t\\t\\t\\t\\\"source_id\\\": \\\"_driver_name_raw\\\",\\r\\n\\t\\t\\t\\t\\\"separator\\\": \\\", \\\",\\r\\n\\t\\t\\t\\t\\\"index\\\": 1\\r\\n\\t\\t\\t}\\r\\n\\t\\t}\\r\\n\\r\\n\\t]\\r\\n}\"\n"
          },
          "version_id": {
            "type": "string",
            "x-internal-note": "version_id is returned by the backend but deliberately not documented publicly."
          },
          "versions": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ConfigurationVersion"
            }
          },
          "content_type": {
            "$ref": "#/components/schemas/ConfigurationContentType"
          },
          "editor": {
            "$ref": "#/components/schemas/ConfigurationEditor"
          }
        },
        "required": [
          "name",
          "created",
          "configuration",
          "version_id",
          "versions",
          "content_type"
        ],
        "additionalProperties": false
      }
    },
    "responses": {
      "400": {
        "description": "Bad Request",
        "content": {
          "text/plain": {
            "schema": {
              "title": "Bad Request",
              "type": "string",
              "example": "Either a specific set of messages about fields in the request, or error messages like the following examples - Not available to logged in users To use the asynchronous flow you must have persistence enabled Specified document type does not exist Specified document type ${named type} does not exist No published configurations found for environment ${environment} Specified golden does not exist Specified configuration/version does not exist Specified configuration/version is not valid Must provide the Content-Type header when request body is present Content-Type must be application/json Missing request body or body.document Could not determine the content type of the document Could not determine the content type of the document. Please check that the document was correctly encoded as Base64 This PDF is invalid. If you submitted this PDF using Base64 encoding, please check that the encoding is correct This PDF is password protected. Please resubmit with password protection disabled This PDF is empty This PDF exceeds the maximum dimensions for OCR of 17 x 17 inches This PDF exceeds the maximum size for OCR of 50MB No fingerprints match for this PDF and fingerprint_mode is set to strict Content type of ${found} does not match declared type of ${expected} Document is not present"
            }
          }
        }
      },
      "401": {
        "description": "Not authorized",
        "content": {
          "text/plain": {
            "schema": {
              "title": "Unauthorized",
              "type": "string",
              "example": "Unauthorized"
            }
          }
        }
      },
      "404": {
        "description": "Not Found",
        "content": {
          "text/plain": {
            "schema": {
              "title": "Not Found",
              "type": "string"
            }
          }
        }
      },
      "415": {
        "description": "Unsupported Media Type",
        "content": {
          "text/plain": {
            "schema": {
              "title": "Unsupported Media Type",
              "type": "string",
              "example": "Messages related to the file format of the document to extract data from."
            }
          }
        }
      },
      "500": {
        "description": "Internal Server Error",
        "content": {
          "text/plain": {
            "schema": {
              "title": "Sensible encountered an unknown error",
              "type": "string",
              "example": "Sensible encountered an unknown error"
            }
          }
        }
      }
    },
    "securitySchemes": {
      "bearerAuth": {
        "type": "http",
        "scheme": "bearer",
        "description": "Sensible uses API keys to authenticate requests. Keep your API keys secure and do not share them publicly accessible areas such as GitHub, client-side code, etc. Authentication to the API is performed via Bearer Authentication. Provide your API key as the bearer auth value."
      }
    }
  },
  "security": [
    {
      "bearerAuth": []
    }
  ]
}
```