> ## 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 Full Details

> Retrieves comprehensive details for a specific dictionary, including all terms and their definitions. Supports optional filtering and pagination to help you find exactly what you need.

## Overview

This endpoint provides you with complete access to a dictionary's content, returning detailed information about the dictionary itself along with all its terms and definitions. Think of this as opening up a physical dictionary and having access to browse through all its entries, but with the added convenience of being able to search for specific terms or limit how many results you see at once.

## Understanding Dictionary Details

When you request full details for a dictionary, you're essentially asking the system to compile a comprehensive view that includes both the dictionary's metadata (information about the dictionary itself) and its complete content. This content consists of all the dictionary's terms along with their corresponding translations or definitions. Think of it as getting both the book's cover information and all the pages inside, delivered together in one complete package.

This comprehensive approach is particularly valuable when you're building multilingual applications, translation tools, or terminology management systems where you need access to both the source terms and their translated equivalents. The full details endpoint delivers this rich content in a structured format that makes it easy to work with term-translation pairs programmatically.

The "full details" approach means you get everything in one request rather than having to make separate calls for dictionary information and then additional calls for each term and its translations. This design helps reduce the number of API calls your application needs to make, which improves performance and simplifies your code while giving you complete access to the dictionary's linguistic content.


## OpenAPI

````yaml get /dictionaries/{dictionary_id}/full-details
openapi: 3.1.0
info:
  title: FastAPI
  version: 0.1.0
servers:
  - url: https://client.camb.ai/apis
security: []
paths:
  /dictionaries/{dictionary_id}/full-details:
    get:
      tags:
        - Apis
        - Dictionaries
      summary: Get Dictionary Details
      operationId: get_dictionary_details_dictionaries__dictionary_id__full_details_get
      parameters:
        - name: dictionary_id
          in: path
          required: true
          schema:
            $ref: '#/components/schemas/DictionaryIDPathParam'
        - name: limit
          in: query
          required: false
          schema:
            type: integer
            nullable: true
            description: >-
              Limit how many terms are returned when fetching the dictionary
              details. You can specify exactly how many terms you want to see.
              For example, setting `limit=50` will return only the first 50
              terms from the dictionary. This is especially useful for
              implementing pagination in user interfaces or when you only need a
              sample of the dictionary's content.
            title: Limit
        - name: search_term
          in: query
          required: false
          schema:
            type: string
            title: Search Term
            nullable: true
            description: >-
              When you provide a search term, the API acts like a search
              function within the dictionary. Rather than returning all terms,
              it will filter the results to show only those terms that match or
              contain your search string. This transforms the endpoint from a
              'show me everything' request into a 'show me what I'm looking for'
              request, making it much more efficient when you're looking for
              specific terminology.
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DictionaryWithTerms'
        '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.
    DictionaryWithTerms:
      allOf:
        - $ref: '#/components/schemas/Dictionary'
        - properties:
            dictionary_terms:
              $ref: '#/components/schemas/TermTranslation'
    HTTPValidationError:
      properties:
        detail:
          items:
            $ref: '#/components/schemas/ValidationError'
          type: array
          title: Detail
      type: object
      title: HTTPValidationError
    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.
    TermTranslation:
      properties:
        translation:
          type: string
          maxLength: 255
          title: Translation
          description: >-
            The translated text of the term in the specified target language.
            This should be the most accurate and contextually appropriate
            translation of the original term.
        language:
          $ref: '#/components/schemas/Languages'
          description: >-
            The target language for this translation. This determines the
            linguistic and cultural context in which the translation should be
            interpreted.
      type: object
      required:
        - translation
        - language
      title: TermTranslation
      description: >-
        Represents a single translation of a term into a specific target
        language. Each object contains the translated text along with its
        corresponding language identifier, enabling multilingual term management
        and localization workflows.
    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
    Languages:
      type: integer
      enum:
        - 1
        - 2
        - 3
        - 4
        - 5
        - 6
        - 7
        - 8
        - 9
        - 10
        - 11
        - 12
        - 13
        - 14
        - 15
        - 16
        - 17
        - 18
        - 19
        - 20
        - 21
        - 22
        - 23
        - 24
        - 25
        - 26
        - 27
        - 28
        - 29
        - 30
        - 31
        - 32
        - 33
        - 34
        - 35
        - 36
        - 37
        - 38
        - 39
        - 40
        - 41
        - 42
        - 43
        - 44
        - 45
        - 46
        - 47
        - 48
        - 49
        - 50
        - 51
        - 52
        - 53
        - 54
        - 55
        - 56
        - 57
        - 58
        - 59
        - 60
        - 61
        - 62
        - 63
        - 64
        - 65
        - 66
        - 67
        - 68
        - 69
        - 70
        - 71
        - 72
        - 73
        - 74
        - 75
        - 76
        - 77
        - 78
        - 79
        - 80
        - 81
        - 82
        - 83
        - 84
        - 85
        - 86
        - 87
        - 88
        - 89
        - 90
        - 91
        - 92
        - 93
        - 94
        - 95
        - 96
        - 97
        - 98
        - 99
        - 100
        - 101
        - 102
        - 103
        - 104
        - 105
        - 106
        - 107
        - 108
        - 109
        - 110
        - 111
        - 112
        - 113
        - 114
        - 115
        - 116
        - 117
        - 118
        - 119
        - 120
        - 121
        - 122
        - 123
        - 124
        - 125
        - 126
        - 127
        - 128
        - 129
        - 130
        - 131
        - 132
        - 133
        - 134
        - 135
        - 136
        - 139
        - 140
        - 141
        - 142
        - 143
        - 144
        - 145
        - 146
        - 147
        - 148
        - 149
        - 150
      title: Languages
      default: 1
  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.

````