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

# Get Dictionary Summary

> Retrieves essential information about a specific dictionary, including its name, description, and metadata. Perfect for getting a quick overview without loading all dictionary terms.

## Overview

Think of this endpoint as looking at the cover and introduction of a book before deciding whether to read the entire thing. When you need to understand what a dictionary contains and when it was created or last modified, but don't need to see all its terms and definitions, this endpoint provides exactly that focused information.
This summary approach serves a fundamentally different purpose than retrieving full dictionary details. While the full details endpoint gives you everything including all terms and definitions, this summary endpoint focuses exclusively on the dictionary's identifying characteristics and metadata. This distinction becomes important when you're building applications that need to display dictionary information efficiently or when you're working with multiple dictionaries and need to present them in lists or selection interfaces.

## Understanding Dictionary Metadata

Every dictionary in the system carries essential information about itself, separate from the actual terms and definitions it contains. This metadata tells the story of the dictionary: what it's called, what it's intended for, when it was created, and when someone last made changes to it. Understanding this information helps you and your users make informed decisions about which dictionaries to work with and whether the content might be current for your needs.
The metadata approach also supports better application architecture. Instead of loading potentially thousands of dictionary terms just to show a user what dictionaries are available, you can quickly retrieve just the summary information for multiple dictionaries, creating responsive user interfaces that load quickly and provide clear choices.


## OpenAPI

````yaml get /dictionaries/{dictionary_id}
openapi: 3.1.0
info:
  title: FastAPI
  version: 0.1.0
servers:
  - url: https://client.camb.ai/apis
security: []
paths:
  /dictionaries/{dictionary_id}:
    get:
      tags:
        - Apis
        - Dictionaries
      summary: Get Dictionary Info
      operationId: get_dictionary_info_dictionaries__dictionary_id__get
      parameters:
        - name: dictionary_id
          in: path
          required: true
          schema:
            $ref: '#/components/schemas/DictionaryIDPathParam'
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Dictionary'
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
      security:
        - APIKeyHeader: []
components:
  schemas:
    DictionaryIDPathParam:
      type: integer
      title: Dictionary Id
      description: >-
        This parameter tells the API exactly which dictionary you're interested
        in. Each dictionary in the system has a unique numerical ID that serves
        as its primary identifier.
    Dictionary:
      properties:
        id:
          type: integer
          title: Dictionary ID
          description: ' The Dictionary''s Unique Identifier. This integer value serves as the dictionary''s permanent address in the system. Once assigned, this ID never changes - It''s how the system definitively identifies this particular collection of terms.'
        name:
          type: string
          title: Dictionary Name
          description: ' The Dictionary''s Display Name. This string contains the human-readable name that identifies the dictionary to users. Unlike the ID, which is purely functional, the name is designed to be meaningful to people who are choosing which dictionary to work with.'
        description:
          type: string
          nullable: true
          title: Dictionary Description
          description: >-
            Detailed Dictionary Information. This optional field can contain a
            longer explanation of what the dictionary covers, its intended
            audience, or special characteristics that set it apart from other
            dictionaries. The description might explain the scope of terms
            included, the expertise level assumed, or specific domains covered.
        created_at:
          type: string
          format: date-time
          title: Creation Date
          description: >-
            Dictionary Creation Timestamp. This date-time value tells you
            exactly when someone first created this dictionary in the system.
            Understanding creation dates helps you gauge how established a
            dictionary is and can be useful for administrative purposes,
            auditing, or simply satisfying curiosity about a dictionary's
            history. The timestamp includes both date and time information,
            giving you precise historical context.
        updated_at:
          type: string
          format: date-time
          title: Update Date
          description: >-
            Last Modification Timestamp. Perhaps one of the most practically
            useful pieces of metadata, this timestamp shows when someone last
            made changes to the dictionary. This could mean adding new terms,
            modifying existing definitions, updating the dictionary's name or
            description, or any other modification. For applications where
            content freshness matters, this timestamp helps you and your users
            understand how current the dictionary's information might be.
    HTTPValidationError:
      properties:
        detail:
          items:
            $ref: '#/components/schemas/ValidationError'
          type: array
          title: Detail
      type: object
      title: HTTPValidationError
    ValidationError:
      properties:
        loc:
          items:
            anyOf:
              - type: string
              - type: integer
          type: array
          title: Location
        msg:
          type: string
          title: Message
        type:
          type: string
          title: Error Type
      type: object
      required:
        - loc
        - msg
        - type
      title: ValidationError
  securitySchemes:
    APIKeyHeader:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        The `x-api-key` is a custom header required for authenticating requests
        to our API. Include this header in your request with the appropriate API
        key value to securely access our endpoints. You can find your API key(s)
        in the 'API' section of our studio website.

````