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

# Get a data store

> Returns everything the store declares — its typed fields, its record key, the complete set of sources that may write to it — plus the precedence in effect for your account and how many records are still awaiting recompute. An unknown store returns 404.



## OpenAPI

````yaml /openapi.json get /data/stores/{store}
openapi: 3.1.0
info:
  title: GetDialed API
  version: 0.1.0
servers:
  - url: https://api.getdialed.ai/v1
    description: Production
security: []
paths:
  /data/stores/{store}:
    get:
      tags:
        - data-stores
      summary: Get a data store
      description: >-
        Returns everything the store declares — its typed fields, its record
        key, the complete set of sources that may write to it — plus the
        precedence in effect for your account and how many records are still
        awaiting recompute. An unknown store returns 404.
      operationId: get_store_data_stores__store__get
      parameters:
        - name: store
          in: path
          required: true
          schema:
            type: string
            title: Store
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StoreDetailResponse'
        '401':
          description: Missing or invalid authentication
          content:
            application/json:
              example:
                detail: Authentication required
        '404':
          description: Not found — also returned on cross-tenant access (never 403)
          content:
            application/json:
              example:
                detail: Store not found
        '422':
          description: Validation error (see body for field details)
          content:
            application/json:
              example:
                detail: Validation error
        '429':
          description: Rate limit exceeded — retry after the Retry-After header
          content:
            application/json:
              example:
                detail: Rate limit exceeded
      security:
        - APIKeyHeader: []
        - HTTPBearer: []
components:
  schemas:
    StoreDetailResponse:
      properties:
        slug:
          type: string
          title: Slug
          description: Identifies the store in every store URL.
        tier:
          type: string
          title: Tier
          description: Which kind of store this is.
        version:
          type: integer
          title: Version
          description: Version of the store's platform declaration.
        record_key:
          $ref: '#/components/schemas/StoreRecordKeyResponse'
        fields:
          additionalProperties:
            $ref: '#/components/schemas/FieldSchema'
          type: object
          title: Fields
          description: Every field the store declares, keyed by field name.
        sources:
          items:
            type: string
          type: array
          title: Sources
          description: Every source that may ever write a layer to this store.
        precedence:
          $ref: '#/components/schemas/StorePrecedenceResponse'
        config_version:
          type: integer
          title: Config Version
          description: >-
            Version of your precedence settings. Every record records the
            version its resolved view was computed with, which is what makes a
            view left behind by a precedence change detectable.
        recompute:
          $ref: '#/components/schemas/StoreRecomputeResponse'
        record_retention_days:
          anyOf:
            - type: integer
            - type: 'null'
          title: Record Retention Days
          description: How long records are kept. Null means indefinitely.
        history_retention_days:
          anyOf:
            - type: integer
            - type: 'null'
          title: History Retention Days
          description: How long history rows are kept. Null means indefinitely.
        changed_event_type:
          type: string
          title: Changed Event Type
          description: >-
            The event emitted when a record's resolved value changes. Subscribe
            to this exact name to react to changes.
        summary_event_type:
          type: string
          title: Summary Event Type
          description: >-
            The event emitted once per completed sync, carrying that sync's
            totals. Subscribe to this one for bulk reactions.
      type: object
      required:
        - slug
        - tier
        - version
        - record_key
        - fields
        - sources
        - precedence
        - config_version
        - recompute
        - changed_event_type
        - summary_event_type
      title: StoreDetailResponse
      description: >-
        Everything one store declares, plus the precedence in effect for you.


        The field map is the store's own type declaration, so a form or table
        can be

        rendered from this response alone — including which values are allowed,
        which

        may be null, and how each value should be handled.
    StoreRecordKeyResponse:
      properties:
        field:
          type: string
          title: Field
          description: Which field of the record is its key.
        format:
          type: string
          title: Format
          description: >-
            The canonical form the key is stored in. `e164` means every key is a
            phone number in E.164 form, and a value that cannot be normalized to
            it is refused rather than stored as written.
      type: object
      required:
        - field
        - format
      title: StoreRecordKeyResponse
      description: How a store's record key is formed.
    FieldSchema:
      properties:
        type:
          type: string
          enum:
            - string
            - number
            - boolean
            - object
            - array
            - datetime
            - connection_ref
          title: Type
        description:
          type: string
          title: Description
        sensitivity:
          type: string
          enum:
            - none
            - pii
            - phi
            - secret
          title: Sensitivity
        required:
          type: boolean
          title: Required
          default: false
        default:
          anyOf:
            - {}
            - type: 'null'
          title: Default
        enum:
          anyOf:
            - items: {}
              type: array
            - type: 'null'
          title: Enum
        example:
          anyOf:
            - {}
            - type: 'null'
          title: Example
        nullable:
          type: boolean
          title: Nullable
          default: false
        items:
          anyOf:
            - $ref: '#/components/schemas/FieldSchema'
            - type: 'null'
        properties:
          anyOf:
            - additionalProperties:
                $ref: '#/components/schemas/FieldSchema'
              type: object
            - type: 'null'
          title: Properties
        group:
          anyOf:
            - type: string
            - type: 'null'
          title: Group
        order:
          anyOf:
            - type: integer
            - type: 'null'
          title: Order
        secret:
          type: boolean
          title: Secret
          default: false
        hidden:
          type: boolean
          title: Hidden
          default: false
      type: object
      required:
        - type
        - description
        - sensitivity
      title: FieldSchema
      description: >-
        Describes a single typed field completely enough to render a form for
        it.


        Every field declares a ``type``, a human-readable ``description``, and a

        ``sensitivity`` classification (``none``, ``pii``, ``phi`` or
        ``secret``), so

        the handling a value requires is always explicit rather than inferred. A

        field classified ``secret`` is always rendered masked.


        ``required``, ``default``, ``enum``, ``example``, ``nullable``,
        ``group`` and

        ``order`` are the presentation and validation hints a generic form
        needs.

        ``items`` describes the element type of an ``array`` and ``properties``

        describes the members of an ``object``. ``hidden`` marks a field that is

        supplied automatically and should never be presented for entry.


        A field of type ``connection_ref`` means "supply a credential here".
        Which

        credentials are acceptable is determined by the service the action
        belongs

        to: for a vendor service, a credential belonging to a tenant of that

        service's platform whose authentication mechanism matches the one the

        service declares; for a first-party service, a credential whose

        authentication kind the service accepts. The field names no service
        itself,

        so the set of acceptable credentials can never go stale against the
        service

        it is read from.
    StorePrecedenceResponse:
      properties:
        default_order:
          items:
            type: string
          type: array
          title: Default Order
          description: The order every field resolves by unless it is overridden.
        field_overrides:
          additionalProperties:
            items:
              type: string
            type: array
          type: object
          title: Field Overrides
          description: >-
            Per-field orders that depart from the default. A field absent here
            uses `default_order`.
      type: object
      required:
        - default_order
      title: StorePrecedenceResponse
      description: >-
        The precedence currently deciding this store's resolved values.


        For each field, the first source in that field's order which asserts a

        value wins. A field's order is also the list of sources allowed to write
        it,

        so one place answers both "who wins" and "who may say anything at all".
    StoreRecomputeResponse:
      properties:
        pending:
          type: integer
          title: Pending
          description: >-
            How many records still carry a resolved view computed with an older
            precedence version. Zero means every record is current.
      type: object
      required:
        - pending
      title: StoreRecomputeResponse
      description: >-
        Whether every record's resolved view reflects the current precedence.


        Changing precedence invalidates the resolved views computed under the
        old

        settings, and they are recomputed in the background. While that is
        running,

        bulk queries legitimately mix records resolved under the old precedence
        with

        records resolved under the new one. `pending` reaching zero is how you
        know

        the window has closed.
  securitySchemes:
    APIKeyHeader:
      type: apiKey
      in: header
      name: X-API-Key
    HTTPBearer:
      type: http
      scheme: bearer
      bearerFormat: JWT

````