> ## Documentation Index
> Fetch the complete documentation index at: https://docs.parable.work/llms.txt
> Use this file to discover all available pages before exploring further.

# Read the data catalog

> Returns this Workspace's catalog of the data that SQL can read.

> **[Read the data catalog](/protocols/_generated/mcp/web-api/catalog-v2#tool-read_data_catalog)**
>
> `read_data_catalog`


## OpenAPI

````yaml /protocols/_generated/openapi/web-api.json get /api/v2/catalog
openapi: 3.0.3
info:
  description: >-
    Use the Workspace API to work with artifacts, connectors, Parables, and
    account resources.
  title: Workspace API
  version: v2026.10.22.1
servers: []
security: []
paths:
  /api/v2/catalog:
    get:
      tags:
        - Catalog version 2
      summary: Read the data catalog
      description: Returns this Workspace's catalog of the data that SQL can read.
      operationId: CatalogV2CatalogHandler
      parameters:
        - description: >-
            Workspace slug. Overrides subdomain-based workspace resolution when
            provided.
          in: header
          name: X-Tenant
          required: false
          schema:
            example: acme
            type: string
        - description: Optional request correlation ID echoed back in the response.
          in: header
          name: X-Request-ID
          required: false
          schema:
            example: 550e8400-e29b-41d4-a716-446655440000
            format: uuid
            type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                properties:
                  data:
                    $ref: '#/components/schemas/SemanticCatalogResponse'
                  links:
                    $ref: '#/components/schemas/ResponseLinks'
                  meta:
                    $ref: '#/components/schemas/ResponseMeta'
                required:
                  - data
                  - meta
                type: object
          description: Successful response
          headers:
            X-Request-ID:
              $ref: '#/components/headers/X-Request-ID'
        '400':
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
          description: The request is not valid. `detail` says why.
          headers:
            X-Request-ID:
              $ref: '#/components/headers/X-Request-ID'
        '401':
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
          description: The token is missing, malformed, revoked, or expired.
          headers:
            X-Request-ID:
              $ref: '#/components/headers/X-Request-ID'
        '403':
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
          description: >-
            The token cannot make this request. For example, the roles of its
            owner do not allow the operation.
          headers:
            X-Request-ID:
              $ref: '#/components/headers/X-Request-ID'
        '500':
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
          description: The request failed on the server.
          headers:
            X-Request-ID:
              $ref: '#/components/headers/X-Request-ID'
      security:
        - bearerAuth: []
      x-codeSamples:
        - label: TypeScript SDK
          lang: typescript
          source: |-
            import { WebApiSDK } from "@parable-platform/web-api-sdk";

            const sdk = new WebApiSDK({
              baseUrl: process.env.PARABLE_API_URL!,
              auth: { token: process.env.PARABLE_API_TOKEN! },
              requestInterceptor: (config) => ({
                ...config,
                headers: { ...config.headers, "X-Tenant": process.env.PARABLE_WORKSPACE! },
              }),
            });

            const result = await sdk.catalogV2.catalog();
        - label: Python SDK
          lang: python
          source: |-
            import os

            from parable_web_api_sdk import ClientConfig, WebApiSDK

            sdk = WebApiSDK(
                ClientConfig(
                    base_url=os.environ["PARABLE_API_URL"],
                    auth_token=os.environ["PARABLE_API_TOKEN"],
                    default_headers={"X-Tenant": os.environ["PARABLE_WORKSPACE"]},
                )
            )

            result = sdk.catalog_v2.catalog()
        - label: Rust SDK
          lang: rust
          source: >-
            use parable_web_api_sdk::{ClientConfig, RequestOptions, WebApiSdk};


            let sdk = WebApiSdk::new(ClientConfig::with_base_url(
                std::env::var("PARABLE_API_URL")?,
                Some(std::env::var("PARABLE_API_TOKEN")?),
                None,
            ))?;

            let options = RequestOptions::with_header("X-Tenant",
            std::env::var("PARABLE_WORKSPACE")?, None, None);


            let result = sdk.catalog_v2.catalog(
                Some(&options)
            ).await?;
        - label: Go SDK
          lang: go
          source: "sdk, err := webapisdk.New(webapisdk.SDKConfig{\n\tBaseURL: os.Getenv(\"PARABLE_API_URL\"),\n\tAuth:    &webapisdk.AuthConfig{Token: os.Getenv(\"PARABLE_API_TOKEN\")},\n\tRequestInterceptor: func(ctx context.Context, req *http.Request) error {\n\t\treq.Header.Set(\"X-Tenant\", os.Getenv(\"PARABLE_WORKSPACE\"))\n\t\treturn nil\n\t},\n})\nif err != nil {\n\treturn err\n}\n\nresult, err := sdk.CatalogV2Namespace.Catalog(ctx)"
components:
  schemas:
    SemanticCatalogResponse:
      description: The workspace's semantic catalog.
      properties:
        catalogVersion:
          description: |-
            Structure-only catalog fingerprint (planner version + plans +
            provider roots + views). Data movement never bumps it; clients may
            key caches on (tenantSlug, catalogVersion).
          type: string
        contractVersion:
          description: >-
            Catalog metadata contract version
            (`parable.metadata.contract_version`).
          type: string
        tables:
          items:
            $ref: '#/components/schemas/SemanticCatalogTable'
          type: array
        tenantSlug:
          description: >-
            Workspace the catalog belongs to (from the request; SYSTEM-1782).
            Same

            type as Tenant.slug, the field it references.
          maxLength: 17
          minLength: 1
          pattern: ^[a-z0-9]+(?:-[a-z0-9]+)*$
          type: string
        views:
          items:
            $ref: '#/components/schemas/SemanticCatalogView'
          type: array
      required:
        - tenantSlug
        - catalogVersion
        - contractVersion
        - tables
        - views
      type: object
    ResponseLinks:
      properties:
        first:
          nullable: true
          type: string
        last:
          nullable: true
          type: string
        next:
          nullable: true
          type: string
        prev:
          nullable: true
          type: string
      type: object
    ResponseMeta:
      properties:
        requestId:
          description: Unique identifier for the request
          type: string
        totalCount:
          description: Total count of items for paginated responses
          nullable: true
          type: integer
      required:
        - requestId
      type: object
    ProblemDetails:
      description: An error response in the Problem Details format (RFC 9457).
      properties:
        code:
          description: The stable error code, when the problem has one.
          example: WA-VL-001
          type: string
        detail:
          description: What went wrong with this request.
          type: string
        details:
          description: >-
            Structured facts about the refusal, such as the entity or the path
            it concerns. Only some refusals have it.
        errors:
          description: >-
            The fields or filters that failed validation. Only a validation or
            filter error has it.
        requestId:
          description: >-
            The ID of the request, when the problem has one. The `X-Request-ID`
            response header always has it.
          type: string
        status:
          description: The HTTP status code.
          example: 400
          type: integer
        title:
          description: A short summary, usually the text of the HTTP status.
          example: Bad Request
          type: string
        type:
          description: >-
            The problem type. It is `about:blank`: the status and `code`
            identify the problem.
          example: about:blank
          type: string
      required:
        - type
        - title
        - status
        - detail
      type: object
    SemanticCatalogTable:
      description: One served base table.
      properties:
        catalog:
          description: >-
            SQL catalog the table is served under (`providers`,

            `providers_quarantine`, or `providers_quality`). A quarantine table
            and a

            quality history table share the schema name of their Provider table,
            so

            the catalog tells them apart.
          type: string
        description:
          description: >-
            What the table holds, from the Provider's description of the Tap or
            its

            documentation. Null when neither describes it. The

            CatalogSnapshot omits it, for the reason given on

            SemanticCatalogField.system.
          nullable: true
          type: string
        fields:
          items:
            $ref: '#/components/schemas/SemanticCatalogField'
          type: array
        importedForeignKeys:
          description: Foreign keys imported by this table. Empty when none are resolved.
          items:
            $ref: '#/components/schemas/SemanticCatalogForeignKey'
          type: array
        logicalName:
          description: Logical table name inside the connector schema.
          type: string
        materialized:
          description: |-
            Whether the writer has materialized the physical table. Null until
            an annotation source answers (unknown, never false-by-default).
          nullable: true
          type: boolean
        primaryKey:
          description: |-
            Ordered logical columns for the table's primary key. Null when the
            planner does not expose a complete primary key.
          oneOf:
            - $ref: '#/components/schemas/SemanticCatalogPrimaryKey'
            - enum:
                - null
              nullable: true
              type: object
        schemaName:
          description: >-
            Catalog SCHEMA SEGMENT the table registers under. For the providers

            catalogs it is a connector slug sanitized for SQL identifiers (`-`

            becomes `_`, e.g. `google-drive` registers as `google_drive`); for
            the

            derived identity-resolution family it is the literal `identity`; for
            the

            artifacts it is the publication namespace (`public` for legacy
            uploads);

            the workspace catalog keeps the literal `public`.
          maxLength: 255
          minLength: 1
          pattern: ^[a-z0-9]+(?:[-_][a-z0-9]+)*$
          type: string
        statsRowCount:
          description: Row count from the annotation source; null when unknown.
          format: int64
          maximum: 9007199254740991
          minimum: -9007199254740991
          nullable: true
          type: integer
        tableKind:
          $ref: '#/components/schemas/CatalogTableKindEnum'
          description: Position in the tap's plan; Flight `parable.annotation.table_kind`.
        tapKind:
          $ref: '#/components/schemas/CatalogTapKindEnum'
          description: >-
            Catalog tap-kind vocabulary kinds plus `derived` for

            platform-synthesized families); Flight
            `parable.annotation.tap_kind`.
        validationRates:
          description: |-
            Per-column validation rates keyed by logical column name. Empty when
            no annotation source answered.
          items:
            $ref: '#/components/schemas/SemanticCatalogValidationRate'
          type: array
        watermark:
          description: Completeness watermark ("complete through T"); null when unknown.
          format: date-time
          nullable: true
          type: string
        watermarkStale:
          nullable: true
          type: boolean
      required:
        - catalog
        - schemaName
        - logicalName
        - tableKind
        - tapKind
        - validationRates
        - importedForeignKeys
        - fields
      type: object
    SemanticCatalogView:
      description: |-
        One opt-in convenience view (LOG-3). The output schema is a planning
        product resolved from the workspace session at request time, exactly as
        Flight GetTables serves it.
      properties:
        fields:
          items:
            $ref: '#/components/schemas/SemanticCatalogField'
          type: array
        logicalName:
          type: string
        schemaName:
          description: >-
            Views register under their parent table's schema segment, same type
            and

            same value rule as SemanticCatalogTable.schemaName.
          maxLength: 255
          minLength: 1
          pattern: ^[a-z0-9]+(?:[-_][a-z0-9]+)*$
          type: string
      required:
        - schemaName
        - logicalName
        - fields
      type: object
    SemanticCatalogField:
      description: >-
        One logical column of a served table or view. The semantic catalog is
        the

        same catalog that SQL over Flight reports in its metadata, with the

        Artifact tables you may read. An omitted (null) annotation field means

        *unknown / not yet computed*. A present value is authoritative. Identity

        fields (tableKind, tapKind, contractVersion) are always present.
      properties:
        arrowType:
          description: |-
            Deterministic Arrow DataType rendering (Arrow's canonical Display
            form). Deliberately a string, not an enum: nested and parameterized
            types render their full parameters (`List(Field { .. Utf8 .. })`,
            `Timestamp(Nanosecond, Some("UTC"))`, `Map(...)`), so the value set
            is open -- it is the exact type served in the Flight IPC schema for
            the same column, which an enum of type families could not carry.
          type: string
        hidden:
          description: >-
            True on Parable's operational columns that the logical schema still

            shows: the `_parable_*` envelope columns of a quarantine table. A
            main

            table's envelope columns are left out of the schema, not flagged.
          type: boolean
        name:
          description: |-
            Logical column name (lowercased source path segments joined with
            `__`), exactly as served by Flight GetTables.
          maxLength: 80
          minLength: 2
          type: string
        nullable:
          type: boolean
        poorPruning:
          description: >-
            True on columns whose physical representation defeats data skipping

            (JSON-encoded, native struct/array, capture buckets). SQL over
            Flight

            serves the same value under the `parable.annotation.poor_pruning`
            field

            metadata key.
          type: boolean
        scalarRef:
          description: >-
            Canonical name of the column's semantic scalar (e.g.
            `Contact.Email`),

            exactly the Flight `parable.scalar.canonical_name` field metadata

            value; null when the column carries no semantic scalar. Consumers

            needing a JSON-Schema pointer can prefix `#/definitions/scalars/`.
          maxLength: 128
          minLength: 3
          nullable: true
          pattern: ^[A-Z][A-Za-z0-9]*\.[A-Z][A-Za-z0-9]*$
          type: string
        system:
          description: >-
            True on the row-state columns Parable adds to every Provider table:

            `dt` and the `_parable_*` load and deletion columns on main and
            child

            tables, and the `_parable_*` envelope plus `dt` on quarantine
            tables.

            They stay queryable; catalog browsers list them apart from the

            Provider's own fields. SQL over Flight serves the same value under
            the

            `parable.annotation.system` field metadata key. `GET
            /api/v2/catalog`

            always sets it.
          nullable: true
          type: boolean
      required:
        - name
        - arrowType
        - nullable
        - hidden
        - poorPruning
      type: object
    SemanticCatalogForeignKey:
      description: An imported foreign key from this table to another served table.
      properties:
        referencedColumns:
          items:
            type: string
          type: array
        referencedSchema:
          description: A URL friendly version of a string
          maxLength: 255
          minLength: 1
          pattern: ^[a-z0-9]+(?:[-_][a-z0-9]+)*$
          type: string
        referencedTable:
          type: string
        sourceColumns:
          items:
            type: string
          type: array
      required:
        - sourceColumns
        - referencedSchema
        - referencedTable
        - referencedColumns
      type: object
    SemanticCatalogPrimaryKey:
      description: Ordered logical columns forming a table's primary key.
      properties:
        columns:
          items:
            type: string
          type: array
      required:
        - columns
      type: object
    CatalogTableKindEnum:
      description: |-
        Position of a served table in its Tap's mapping plan. SQL over Flight
        serves the same values under the `parable.annotation.table_kind` schema
        metadata key.
      enum:
        - main
        - quarantine
        - child
        - child_quarantine
      type: string
    CatalogTapKindEnum:
      description: |-
        The kind of Tap behind a served table. SQL over Flight serves the same
        values under the `parable.annotation.tap_kind` schema metadata key. A
        served table comes from one of the Workspace's Taps (the Tap kinds), or
        Parable builds it (DERIVED).
      enum:
        - override
        - custom
        - artifact
        - derived
      type: string
    SemanticCatalogValidationRate:
      description: |-
        Per-column validation rate (logical column name -> rate string), from
        the Flight `parable.annotation.validation_rate.{column}` keys.
      properties:
        column:
          type: string
        rate:
          type: string
      required:
        - column
        - rate
      type: object
  headers:
    X-Request-ID:
      description: >-
        The ID of the request. It is the `X-Request-ID` value that you sent, or
        an ID that the server made. Give it when you report a problem.
      schema:
        type: string
  securitySchemes:
    bearerAuth:
      description: >-
        A personal access token, which starts with `pat_`. A Parable token can
        call each operation that the roles of its owner allow. An MCP token can
        call only the read operations that are open to agents. A SQL token does
        not work on this API.
      scheme: bearer
      type: http

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.