openapi: 3.0.0
servers:
  - url: https://od-api-demo.oxforddictionaries.com:443/api/v1
x-hasEquivalentPaths: true
info:
  license:
    name: API Terms And Conditions
    url: https://developer.oxforddictionaries.com/api-terms-and-conditions
  termsOfService: http://helloreverb.com/terms/
  title: Oxford Dictionaries
  version: 1.11.0
  x-apisguru-categories:
    - text
  x-logo:
    url: https://twitter.com/OxfordWordsAPI/profile_image?size=original
  x-origin:
    - format: openapi
      url: https://developer.oxforddictionaries.com/swagger/spec/public_doc_guest.json
      version: "3.0"
  x-providerName: oxforddictionaries.com
paths:
  "/domains/{source_domains_language}/{target_domains_language}":
    get:
      description: |
        Returns a list of the available [domains](documentation/glossary?term=domain) for a given bilingual language dataset.
      parameters:
        - description: IANA language code
          in: path
          name: source_domains_language
          required: true
          schema:
            enum:
              - en
              - es
              - nso
              - zu
              - ur
              - de
              - pt
            type: string
        - description: IANA language code
          in: path
          name: target_domains_language
          required: true
          schema:
            enum:
              - es
              - nso
              - zu
              - ms
              - id
              - tn
              - ro
              - de
              - pt
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UtilityLabels"
          description: Successful response.
        "400":
          description: source_language and target_language are same.
        "404":
          description: Unknown source_language and/or target_language.
      summary: Lists available domains in a bilingual dataset
      tags:
        - Utility
  "/domains/{source_language}":
    get:
      description: |
        Returns a list of the available [domains](documentation/glossary?term=domain) for a given monolingual language dataset.
      parameters:
        - description: IANA language code
          in: path
          name: source_language
          required: true
          schema:
            enum:
              - en
              - es
              - nso
              - zu
              - hi
              - sw
              - ur
              - de
              - pt
              - ta
              - gu
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UtilityLabels"
          description: Successful response.
        "404":
          description: Unknown source_language.
      summary: Lists available domains in a monolingual dataset
      tags:
        - Utility
  "/entries/{source_language}/{word_id}/sentences":
    get:
      description: |
        
        Use this to retrieve sentences extracted from  corpora which show how a word is used in the language. This is available for English and Spanish. For English, the sentences are linked to the correct [sense](documentation/glossary?term=sense) of the word in the dictionary. In Spanish, they are linked at the [headword](documentation/glossary?term=headword) level.
          <div id="sentences"></div>
      externalDocs:
        description: find more info here
        url: https://helloreverb.com/about
      parameters:
        - description: IANA language code
          in: path
          name: source_language
          required: true
          schema:
            enum:
              - en
              - es
            type: string
        - description: An Entry identifier. Case-sensitive.
          in: path
          name: word_id
          required: true
          schema:
            default: ace
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/SentencesResults"
          description: Successful response.
        "404":
          description: |
            No entry is found matching supplied id and source_language
        "500":
          description: |
            Internal Error. An error occurred while processing the data.
      summary: Retrieve corpus sentences for a given word
      tags:
        - The Sentence Dictionary
  "/entries/{source_lang}/{word_id}":
    get:
      description: |
        
        Use this to retrieve definitions, [pronunciations](documentation/glossary?term=pronunciation), example sentences, [grammatical information](documentation/glossary?term=grammaticalfeatures) and [word origins](documentation/glossary?term=etymology). It only works for dictionary [headwords](documentation/glossary?term=headword), so you may need to use the [Lemmatron](documentation/glossary?term=lemma) first if your input is likely to be an [inflected](documentation/glossary?term=inflection) form (e.g., 'swimming'). This would return the linked [headword](documentation/glossary?term=headword) (e.g., 'swim') which you can then use in the Entries endpoint. Unless specified using a region filter, the default lookup will be the Oxford Dictionary of English (GB). 
          <div id="dictionary_entries"></div>
      externalDocs:
        description: find more info here
        url: https://helloreverb.com/about
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
              - es
              - lv
              - hi
              - sw
              - ta
              - gu
              - fr
            type: string
        - description: An Entry identifier. Case-sensitive.
          in: path
          name: word_id
          required: true
          schema:
            default: ace
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/RetrieveEntry"
          description: Successful response.
        "404":
          description: |
            No entry is found matching supplied id and source_lang or filters are not recognized
        "500":
          description: |
            Internal Error. An error occurred while processing the data.
      summary: Retrieve dictionary information for a given word
      tags:
        - Dictionary entries
  "/entries/{source_lang}/{word_id}/antonyms":
    get:
      description: |
        
        Retrieve words that are opposite in meaning to the input word ([antonym](documentation/glossary?term=thesaurus)).

          <div id="antonyms"></div>
      externalDocs:
        description: find more info here
        url: https://helloreverb.com/about
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
            type: string
        - description: An Entry identifier. Case-sensitive.
          in: path
          name: word_id
          required: true
          schema:
            default: ace
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Thesaurus"
          description: Successful response.
        "404":
          description: |
            No entry is found matching supplied id and source_lang or filters are not recognized
        "500":
          description: |
            Internal Error. An error occurred while processing the data.
      summary: Retrieve words that mean the opposite
      tags:
        - Thesaurus
  "/entries/{source_lang}/{word_id}/regions={region}":
    get:
      description: |
        
        USe this filter to restrict the lookup to either our Oxford Dictionary of English (GB) or New Oxford American Dictionary (US).
      externalDocs:
        description: find more info here
        url: https://helloreverb.com/about
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
            type: string
        - description: An Entry identifier. Case-sensitive.
          in: path
          name: word_id
          required: true
          schema:
            default: ace
            type: string
        - description: Region filter parameter. gb = Oxford Dictionary of English. us = New Oxford American Dictionary.
          in: path
          name: region
          required: true
          schema:
            enum:
              - gb
              - us
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/RetrieveEntry"
          description: Successful response.
        "404":
          description: |
            no entry is found matching supplied source_lang and id
            and/or that entry has no senses with translations in the target language. 
        "500":
          description: |
            Internal Error. An error occurred while processing the data.
      summary: Specify GB or US dictionary for English entry search
      tags:
        - Dictionary entries
  "/entries/{source_lang}/{word_id}/synonyms":
    get:
      description: |
        
        Use this to retrieve words that are similar in meaning to the input word ([synonym](documentation/glossary?term=synonym)).

          <div id="synonyms"></div>
      externalDocs:
        description: find more info here
        url: https://helloreverb.com/about
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
            type: string
        - description: An Entry identifier. Case-sensitive.
          in: path
          name: word_id
          required: true
          schema:
            default: ace
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Thesaurus"
          description: Successful response.
        "404":
          description: |
            No entry is found matching supplied id and source_lang or filters are not recognized
        "500":
          description: |
            Internal Error. An error occurred while processing the data.
      summary: Retrieve words that are similar
      tags:
        - Thesaurus
  "/entries/{source_lang}/{word_id}/synonyms;antonyms":
    get:
      description: |
        
        Retrieve available [synonyms](documentation/glossary?term=thesaurus) and [antonyms](documentation/glossary?term=thesaurus) for a given word and language. 

          <div id="synonyms_and_antonyms"></div>
      externalDocs:
        description: find more info here
        url: https://helloreverb.com/about
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
            type: string
        - description: An Entry identifier. Case-sensitive.
          in: path
          name: word_id
          required: true
          schema:
            default: ace
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Thesaurus"
          description: Successful response.
        "404":
          description: |
            No entry is found matching supplied id and source_lang or filters are not recognized
        "500":
          description: |
            Internal Error. An error occurred while processing the data.
      summary: Retrieve synonyms and antonyms for a given word
      tags:
        - Thesaurus
  "/entries/{source_lang}/{word_id}/{filters}":
    get:
      description: |
        
        Use filters to limit the [entry](documentation/glossary?term=entry) information that is returned. For example, you may only require definitions and not everything else, or just [pronunciations](documentation/glossary?term=pronunciation). The full list of filters can be retrieved from the filters Utility endpoint. You can also specify values within the filter using '='. For example 'grammaticalFeatures=singular'. Filters can also be combined using a semicolon.

          <div id="dictionary_entries_filters"></div>
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
              - es
              - lv
              - hi
              - sw
              - ta
              - gu
              - fr
            type: string
        - description: An Entry identifier. Case-sensitive.
          in: path
          name: word_id
          required: true
          schema:
            default: ace
            type: string
        - description: Separate filtering conditions using a semicolon. Conditions take values grammaticalFeatures and/or lexicalCategory and are case-sensitive. To list multiple values in single condition divide them with comma.
          in: path
          name: filters
          required: true
          schema:
            default: grammaticalFeatures=singular,past;lexicalCategory=noun
            items:
              pattern: (lexicalCategory|grammaticalFeatures)=.+
              type: string
            type: string
          style: simple
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/RetrieveEntry"
          description: Successful response.
        "404":
          description: |
            no entry is found matching supplied source_lang and id
            and/or that entry has no senses with translations in the target language. 
        "500":
          description: |
            Internal Error. An error occurred while processing the data.
      summary: Apply filters to response
      tags:
        - Dictionary entries
  "/entries/{source_translation_language}/{word_id}/translations={target_translation_language}":
    get:
      description: |
        
        Use this to return translations for a given word. In the event that a word in the dataset does not have a direct translation, the response will be a [definition](documentation/glossary?term=entry) in the target language.

          <div id="translation"></div>
      parameters:
        - description: IANA language code
          in: path
          name: source_translation_language
          required: true
          schema:
            enum:
              - en
              - es
              - nso
              - zu
              - ms
              - id
              - tn
              - ur
              - de
              - pt
            type: string
        - description: The source word
          in: path
          name: word_id
          required: true
          schema:
            default: change
            type: string
        - description: IANA language code
          in: path
          name: target_translation_language
          required: true
          schema:
            enum:
              - es
              - nso
              - zu
              - ms
              - id
              - tn
              - ro
              - de
              - pt
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/RetrieveEntry"
          description: Successful response. In case word doesn't have a direct translation a response would be definitions.
        "400":
          description: any of target languages is unknown
        "404":
          description: |
            no entry is found matching supplied source_lang and id
            and/or that entry has no senses with translations in the target language(s). 
        "500":
          description: |
            Internal Error. An error occurred while processing the data.
      summary: Retrieve translation for a given word
      tags:
        - Translation
  /filters:
    get:
      description: |
        Returns a list of all the valid filters to construct API calls.
      parameters:
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Filters"
          description: Successful response.
        "500":
          description: Internal Error. An error occurred while processing the data.
      summary: Lists available filters
      tags:
        - Utility
  "/filters/{endpoint}":
    get:
      description: |
        Returns a list of all the valid filters for a given endpoint to construct API calls.
      parameters:
        - description: Name of the endpoint.
          in: path
          name: endpoint
          required: true
          schema:
            enum:
              - entries
              - inflections
              - translations
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Filters"
          description: Successful response.
        "404":
          description: Unknown endpoint.
        "500":
          description: Internal Error. An error occurred while processing the data.
      summary: Lists available filters for specific endpoint
      tags:
        - Utility
  "/grammaticalFeatures/{source_language}":
    get:
      description: |
        Returns a list of the available [grammatical features](documentation/glossary?term=grammaticalfeatures) for a given language dataset.
      parameters:
        - description: IANA language code. If provided output will be filtered by sourceLanguage.
          in: path
          name: source_language
          required: true
          schema:
            enum:
              - en
              - es
              - lv
              - nso
              - zu
              - ms
              - tn
              - ur
              - hi
              - sw
              - de
              - pt
              - ta
              - gu
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UtilityLabels"
          description: Successful response.
        "404":
          description: Unknown source_language.
      summary: Lists available grammatical features in a dataset
      tags:
        - Utility
  "/inflections/{source_lang}/{word_id}/{filters}":
    get:
      description: |
        
        Use this to check if a word exists in the dictionary, or what 'root' form it links to (e.g., swimming > swim). The response tells you the possible [lemmas](documentation/glossary?term=lemma) for a given [inflected](documentation/glossary?term=inflection) word. This can then be combined with other endpoints to retrieve more information.

          <div id="lemmatron"></div>
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
              - es
              - hi
              - nso
              - tn
              - zu
              - de
              - pt
            type: string
        - description: Separate filtering conditions using a semicolon. Conditions take values grammaticalFeatures and/or lexicalCategory and are case-sensitive. To list multiple values in single condition divide them with comma.
          in: path
          name: filters
          required: true
          schema:
            default: grammaticalFeatures=singular,past;lexicalCategory=noun
            items:
              pattern: (lexicalCategory|grammaticalFeatures)=.+
              type: string
            type: string
          style: simple
        - description: The input word
          in: path
          name: word_id
          required: true
          schema:
            default: swimming
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Lemmatron"
          description: Successful response.
        "500":
          description: |
            Internal Error. An error occurred while processing the data.
      summary: Check a word exists in the dictionary and retrieve its root form
      tags:
        - Lemmatron
  /languages:
    get:
      description: |
        Returns a list of monolingual and bilingual language datasets available in the API
      parameters:
        - description: IANA language code. If provided output will be filtered by sourceLanguage.
          in: query
          name: sourceLanguage
          required: false
          schema:
            enum:
              - es
              - en
              - lv
              - nso
              - zu
              - ms
              - id
              - tn
              - ur
              - hi
              - sw
              - ro
              - de
              - pt
              - ta
              - gu
            type: string
        - description: IANA language code. If provided output will be filtered by sourceLanguage.
          in: query
          name: targetLanguage
          required: false
          schema:
            enum:
              - es
              - en
              - lv
              - nso
              - zu
              - ms
              - id
              - tn
              - ur
              - hi
              - sw
              - ro
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Languages"
          description: Successful response.
        "404":
          description: Unknown sourceLanguage and/or targetLanguage.
        "500":
          description: Internal Error. An error occurred while processing the data.
      summary: Lists available dictionaries
      tags:
        - Utility
  "/lexicalcategories/{language}":
    get:
      description: |
        Returns a list of available [lexical categories](documentation/glossary?term=lexicalcategory) for a given language dataset.
      parameters:
        - description: IANA language code
          in: path
          name: language
          required: true
          schema:
            enum:
              - es
              - en
              - lv
              - nso
              - zu
              - ms
              - id
              - tn
              - ur
              - hi
              - sw
              - ro
              - de
              - pt
              - ta
              - gu
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UtilityLabels"
          description: Successful response.
        "404":
          description: Unknown language.
        "500":
          description: Internal Error. An error occurred while processing the data.
      summary: Lists available lexical categories in a dataset
      tags:
        - Utility
  "/regions/{source_language}":
    get:
      description: |
        Returns a list of the available [regions](documentation/glossary?term=regions) for a given monolingual language dataset.
      parameters:
        - description: IANA language code
          in: path
          name: source_language
          required: true
          schema:
            enum:
              - en
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Regions"
          description: Successful response.
        "404":
          description: Unknown source_language.
      summary: Lists available regions in a monolingual dataset
      tags:
        - Utility
  "/registers/{source_language}":
    get:
      description: |
        Returns a list of the available [registers](documentation/glossary?term=registers) for a given monolingual language dataset.
      parameters:
        - description: IANA language code
          in: path
          name: source_language
          required: true
          schema:
            enum:
              - en
              - es
              - hi
              - id
              - lv
              - ms
              - sw
              - ur
              - de
              - pt
              - ta
              - gu
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UtilityLabels"
          description: Successful response.
        "404":
          description: Unknown source_language.
        "500":
          description: Internal Error. An error occurred while processing the data.
      summary: Lists available registers in a  monolingual dataset
      tags:
        - Utility
  "/registers/{source_register_language}/{target_register_language}":
    get:
      description: |
        Returns a list of the available [registers](documentation/glossary?term=registers) for a given bilingual language dataset.
      parameters:
        - description: IANA language code
          in: path
          name: source_register_language
          required: true
          schema:
            enum:
              - en
              - es
              - ms
              - id
              - ur
              - de
              - pt
            type: string
        - description: IANA language code
          in: path
          name: target_register_language
          required: true
          schema:
            enum:
              - es
              - en
              - nso
              - zu
              - ms
              - id
              - tn
              - ro
              - de
              - pt
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/UtilityLabels"
          description: Successful response.
        "400":
          description: source_language and target_language are same.
        "404":
          description: Unknown source_language and/or target_language.
        "500":
          description: Internal Error. An error occurred while processing the data.
      summary: Lists available registers in a bilingual dataset
      tags:
        - Utility
  "/search/{source_lang}":
    get:
      description: |
        
        Use this to retrieve possible [headword](documentation/glossary?term=headword) matches for a given string of text. The results are culculated using headword matching, fuzzy matching, and [lemmatization](documentation/glossary?term=lemma) 

          <div id="search"></div>
      externalDocs:
        description: find more info here
        url: https://helloreverb.com/about
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
              - es
              - hi
              - lv
              - sw
              - ta
              - gu
            type: string
        - description: Search string
          in: query
          name: q
          required: false
          schema:
            default: eye
            type: string
        - description: Set prefix to true if you'd like to get results only starting with search string.
          in: query
          name: prefix
          required: false
          schema:
            default: "false"
            enum:
              - "false"
              - "true"
            type: boolean
        - description: If searching in English, filter words with specific region(s) either 'us' or 'gb'.
          in: query
          name: regions
          required: false
          schema:
            type: string
        - description: Limit the number of results per response. Default and maximum limit is 5000.
          in: query
          name: limit
          required: false
          schema:
            type: string
        - description: Offset the start number of the result.
          in: query
          name: offset
          required: false
          schema:
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Wordlist"
          description: Successful response.
        "404":
          description: |
            No entry is found matching supplied id and source_lang or filters are not recognized
        "500":
          description: |
            Internal Error. An error occurred while processing the data.
      summary: Retrieve possible matches to input
      tags:
        - Search
  "/search/{source_search_language}/translations={target_search_language}":
    get:
      description: |
        
        Use this to find matches in our translation dictionaries.

          <div id="search_translation"></div>
      externalDocs:
        description: find more info here
        url: https://helloreverb.com/about
      parameters:
        - description: IANA language code
          in: path
          name: source_search_language
          required: true
          schema:
            enum:
              - en
              - es
              - nso
              - zu
              - ms
              - id
              - tn
              - ur
              - de
              - pt
            type: string
        - description: IANA language code
          in: path
          name: target_search_language
          required: true
          schema:
            enum:
              - es
              - nso
              - zu
              - ms
              - id
              - tn
              - ro
              - de
              - pt
            type: string
        - description: Search string.
          in: query
          name: q
          required: false
          schema:
            default: eye
            type: string
        - description: Set prefix to true if you'd like to get results only starting with search string.
          in: query
          name: prefix
          required: false
          schema:
            default: "false"
            enum:
              - "false"
              - "true"
            type: boolean
        - description: Filter words with specific region(s) E.g., regions=us. For now gb, us are available for en language.
          in: query
          name: regions
          required: false
          schema:
            type: string
        - description: Limit the number of results per response. Default and maximum limit is 5000.
          in: query
          name: limit
          required: false
          schema:
            type: string
        - description: Offset the start number of the result.
          in: query
          name: offset
          required: false
          schema:
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Wordlist"
          description: Successful response.
        "404":
          description: |
            No entry is found matching supplied id and source_lang or filters are not recognized
        "500":
          description: |
            Internal Error. An error occurred while processing the data.
      summary: Retrieve possible translation matches to input
      tags:
        - Search
  "/stats/frequency/ngrams/{source_lang}/{corpus}/{ngram-size}/":
    get:
      description: |
        This endpoint returns frequencies of ngrams of size 1-4. That is the number of times a word (ngram size = 1) or words (ngram size > 1) appear in the corpus. Ngrams are case sensitive ("I AM" and "I am" will have different frequency) and frequencies are calculated per word (true case) so "the book" and "the books" are two different ngrams. The results can be filtered based on query parameters. <br> <br> Parameters can be provided in PATH, GET or POST (form or json). The parameters in PATH are overridden by parameters in GET, POST and json (in that order). In PATH, individual options are separated by semicolon and values are separated by commas (where multiple values can be used). <br> <br> Example for bigrams (ngram of size 2):
        * PATH: /tokens=a word,another word
        * GET: /?tokens=a word&tokens=another word
        * POST (json):

          ```javascript
            {
                "tokens": ["a word", "another word"]
            }
          ```

        Either "tokens" or "contains" has to be provided. <br> <br> Some queries with "contains" or "sort" can exceed the 30s timeout, in which case the API will return an error message with status code 503. You mitigate this by providing additional restrictions such as "minFrequency" and "maxFrequency". <br> <br> You can use the parameters "offset" and "limit" to paginate through large result sets. For convenience, the HTTP header "Link" is set on the response to provide links to "first", "self", "next", "prev" and "last" pages of results (depending on the context). For example, if the result set contains 50 results and the parameter "limit" is set to 25, the Links header will contain an URL for the first 25 results and the next 25 results. <br> <br> Some libraries such as python's `requests` can parse the header automatically and offer a convenient way of iterating through the results. For example:
        ```python def get_all_results(url):
            while url:
                r = requests.get(url)
                r.raise_for_status()
                for item in r.json()['results']:
                  yield item
                url = r.links.get('next', {}).get('url')
        ```
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            default: en
            type: string
        - description: For corpora other than 'nmc' (New Monitor Corpus) please contact api@oxforddictionaries.com
          in: path
          name: corpus
          required: true
          schema:
            default: nmc
            type: string
        - description: the size of ngrams requested (1-4)
          in: path
          name: ngram-size
          required: true
          schema:
            default: 2
            type: string
        - description: List of tokens to filter. The tokens are separated by spaces, the list items are separated by comma (e.g., for bigrams (n=2) tokens=this is,this was, this will)
          in: query
          name: tokens
          required: false
          schema:
            default: a word
            type: string
        - description: Find ngrams containing the given token(s). Use comma or space as token separators; the order of tokens is irrelevant.
          in: query
          name: contains
          required: false
          schema:
            type: string
        - description: Flag specifying whether to lookup ngrams that include punctuation or not (possible values are "true" and "false"; default is "false")
          in: query
          name: punctuation
          required: false
          schema:
            type: string
        - description: Option specifying whether tokens should be returned as a single string (option "google") or as a list of strings (option "oup")
          in: query
          name: format
          required: false
          schema:
            default: oup
            type: string
        - description: Restrict the query to entries with frequency of at least `minFrequency`
          in: query
          name: minFrequency
          required: false
          schema:
            format: int64
            type: integer
        - description: Restrict the query to entries with frequency of at most `maxFrequency`
          in: query
          name: maxFrequency
          required: false
          schema:
            format: int64
            type: integer
        - description: Restrict the query to entries that appear in at least `minDocumentFrequency` documents
          in: query
          name: minDocumentFrequency
          required: false
          schema:
            format: int64
            type: integer
        - description: Restrict the query to entries that appera in at most `maxDocumentFrequency` documents
          in: query
          name: maxDocumentFrequency
          required: false
          schema:
            format: int64
            type: integer
        - description: collate the results by wordform, trueCase, lemma, lexicalCategory. Multiple values can be separated by commas (e.g., collate=trueCase,lemma,lexicalCategory).
          in: query
          name: collate
          required: false
          schema:
            type: string
        - description: sort the resulting list by wordform, trueCase, lemma, lexicalCategory, frequency, normalizedFrequency. Descending order is achieved by prepending the value with the minus sign ('-'). Multiple values can be separated by commas (e.g., sort=lexicalCategory,-frequency)
          in: query
          name: sort
          required: false
          schema:
            type: string
        - description: pagination - results offset
          in: query
          name: offset
          required: false
          schema:
            default: 0
            format: int64
            type: integer
        - description: pagination - results limit
          in: query
          name: limit
          required: false
          schema:
            default: 100
            format: int64
            type: integer
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/NgramsResult"
            text/csv:
              schema:
                $ref: "#/components/schemas/NgramsResult"
          description: Successful response.
        "400":
          description: |
            Invalid option name...
        "404":
          description: |
            language is not in...
        "500":
          description: |
            Internal Error. An error occurred while processing the data.
      summary: Retrieve the frequency of ngrams (1-4) derived from a corpus
      tags:
        - LexiStats
  "/stats/frequency/word/{source_lang}/":
    get:
      description: |
        This endpoint provides the frequency of a given word. When multiple database records match the query parameters, the returned frequency is the sum of the individual frequencies. For example, if the query parameters are lemma=test, the returned frequency will include the verb "test", the noun "test" and the adjective "test" in all forms (Test, tested, testing, etc.) <br> <br> If you are interested in the frequency of the word "test" but want to exclude other forms (e.g., tested) use the option trueCase=test. Normally, the word "test" will be spelt with a capital letter at the beginning of a sentence. The option trueCase will ignore this and it will count "Test" and "test" as the same token. If you are interested in frequencies of "Test" and "test", use the option wordform=test or wordform=Test. Note that trueCase is not just a lower case of the word as some words are genuinely spelt with a capital letter such as the word "press" in Oxford University Press. <br> <br> Parameters can be provided in PATH, GET or POST (form or json). The parameters in PATH are overriden by parameters in GET, POST and json (in that order). In PATH, individual options are separated by semicolon and values are separated by commas (where multiple values can be used). Examples:
        * PATH: /lemma=test;lexicalCategory=noun
        * GET: /?lemma=test&lexicalCategory=noun
        * POST (json):

          ```javascript
            {
              "lemma": "test",
              "lexicalCategory": "noun"
            }
          ```

        <br> One of the options wordform/trueCase/lemma/lexicalCategory has to be provided.
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            default: en
            type: string
        - description: For corpora other than 'nmc' (New Monitor Corpus) please contact api@oxforddictionaries.com
          in: query
          name: corpus
          required: false
          schema:
            default: nmc
            type: string
        - description: The written form of the word to look up (preserving case e.g., Books vs books)
          in: query
          name: wordform
          required: false
          schema:
            type: string
        - description: The written form of the word to look up with normalised case (Books --> books)
          in: query
          name: trueCase
          required: false
          schema:
            type: string
        - description: The lemma of the word to look up (e.g., Book, booked, books all have the lemma "book")
          in: query
          name: lemma
          required: false
          schema:
            default: test
            type: string
        - description: The lexical category of the word(s) to look up (e.g., noun or verb)
          in: query
          name: lexicalCategory
          required: false
          schema:
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/StatsWordResult"
            text/csv:
              schema:
                $ref: "#/components/schemas/StatsWordResult"
          description: Successful response.
        "400":
          description: |
            You need to specify at least one option. Try one of 'wordform, lemma, trueCase, lexicalCategory'.
        "404":
          description: |
            language is not in...
        "500":
          description: |
            Internal Error. An error occurred while processing the data.
      summary: Retrieve the frequency of a word derived from a corpus.
      tags:
        - LexiStats
  "/stats/frequency/words/{source_lang}/":
    get:
      description: |
        This endpoint provides a list of frequencies for a given word or words. Unlike the /word/ endpoint, the results are split into the smallest units. <br> <br> To exclude a specific value, prepend it with the minus sign ('-'). For example, to get frequencies of the lemma 'happy' but exclude superlative forms (i.e., happiest) you could use options 'lemma=happy;grammaticalFeatures=-degreeType:superlative'. <br> <br> Parameters can be provided in PATH, GET or POST (form or json). The parameters in PATH are overridden by parameters in GET, POST and json (in that order). In PATH, individual options are separated by semicolon and values are separated by commas (where multiple values can be used). <br> <br> The parameters wordform/trueCase/lemma/lexicalCategory also exist in a plural form, taking a lists of items. Examples:
        * PATH: /wordforms=happy,happier,happiest
        * GET: /?wordforms=happy&wordforms=happier&wordforms=happiest
        * POST (json):
        ```javascript
          {
            "wordforms": ["happy", "happier", "happiest"]
          }
        ```
        A mor complex example of retrieving frequencies of multiple lemmas:
        ```
          {
              "lemmas": ["happy", "content", "cheerful", "cheery", "merry", "joyful", "ecstatic"],
              "grammaticalFeatures": {
                  "adjectiveFunctionType": "predicative"
              },
              "lexicalCategory": "adjective",
              "sort": ["lemma", "-frequency"]
          }
        ```
        Some queries with "collate" or "sort" can exceed the 30s timeout, in which case the API will return an error message with status code 503. You mitigate this by providing additional restrictions such as "minFrequency" and "maxFrequency". <br> <br> You can use the parameters "offset" and "limit" to paginate through large result sets. For convenience, the HTTP header "Link" is set on the response to provide links to "first", "self", "next", "prev" and "last" pages of results (depending on the context). For example, if the result set contains 50 results and the parameter "limit" is set to 25, the Links header will contain an URL for the first 25 results and the next 25 results. <br> <br> Some libraries such as python's `requests` can parse the header automatically and offer a convenient way of iterating through the results. For example:
        ```python def get_all_results(url):
            while url:
                r = requests.get(url)
                r.raise_for_status()
                for item in r.json()['results']:
                  yield item
                url = r.links.get('next', {}).get('url')
        ```
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            default: en
            type: string
        - description: For corpora other than 'nmc' (New Monitor Corpus) please contact api@oxforddictionaries.com
          in: query
          name: corpus
          required: false
          schema:
            default: nmc
            type: string
        - description: The written form of the word to look up (preserving case e.g., Book vs book)
          in: query
          name: wordform
          required: false
          schema:
            type: string
        - description: The written form of the word to look up with normalised case (Books --> books)
          in: query
          name: trueCase
          required: false
          schema:
            type: string
        - description: The lemma of the word to look up (e.g., Book, booked, books all have the lemma "book")
          in: query
          name: lemma
          required: false
          schema:
            default: test
            type: string
        - description: The lexical category of the word(s) to look up (e.g., adjective or noun)
          in: query
          name: lexicalCategory
          required: false
          schema:
            type: string
        - description: The grammatical features of the word(s) to look up entered as a list of k:v (e.g., degree_type:comparative)
          in: query
          name: grammaticalFeatures
          required: false
          schema:
            type: string
        - description: sort the resulting list by wordform, trueCase, lemma, lexicalCategory, frequency, normalizedFrequency. Descending order is achieved by prepending the value with the minus sign ('-'). Multiple values can be separated by commas (e.g., sort=lexicalCategory,-frequency)
          in: query
          name: sort
          required: false
          schema:
            type: string
        - description: collate the results by wordform, trueCase, lemma, lexicalCategory. Multiple values can be separated by commas (e.g., collate=trueCase,lemma,lexicalCategory).
          in: query
          name: collate
          required: false
          schema:
            type: string
        - description: Restrict the query to entries with frequency of at least `minFrequency`
          in: query
          name: minFrequency
          required: false
          schema:
            format: int64
            type: integer
        - description: Restrict the query to entries with frequency of at most `maxFrequency`
          in: query
          name: maxFrequency
          required: false
          schema:
            format: int64
            type: integer
        - description: Restrict the query to entries with frequency of at least `minNormalizedFrequency`
          in: query
          name: minNormalizedFrequency
          required: false
          schema:
            format: float
            type: number
        - description: Restrict the query to entries with frequency of at most `maxNormalizedFrequency`
          in: query
          name: maxNormalizedFrequency
          required: false
          schema:
            format: float
            type: number
        - description: pagination - results offset
          in: query
          name: offset
          required: false
          schema:
            default: 0
            format: int64
            type: integer
        - description: pagination - results limit
          in: query
          name: limit
          required: false
          schema:
            default: 100
            format: int64
            type: integer
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/StatsWordResultList"
            text/csv:
              schema:
                $ref: "#/components/schemas/StatsWordResultList"
          description: Successful response.
        "400":
          description: Invalid option name...; Option ... must have a value.; The option 'minFrequency' has to have an non-negative integer parameter.; The option 'maxFrequency' has to have an non-negative integer parameter.; The option 'limit' has to have an non-negative integer parameter.; The option 'offset' has to have an non-negative integer parameter.
        "404":
          description: |
            language is not in...
        "500":
          description: |
            Internal Error. An error occurred while processing the data.
      summary: Retrieve a list of frequencies of a word/words derived from a corpus.
      tags:
        - LexiStats
  "/wordlist/{source_lang}/{filters_advanced}":
    get:
      description: |
        Use this to apply more complex filters to the [list of words](documentation/glossary?term=wordlist). For example, you may only want to filter out words for which all [senses](documentation/glossary?term=sense) match the filter, or only its 'prime sense'. You can also filter by word length or match by substring (prefix). 

          <div id="wordlist_advanced"></div>
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
              - es
              - hi
              - lv
              - sw
              - ta
              - gu
            type: string
        - description: "Semicolon separated list of wordlist parameters, presented as value pairs: LexicalCategory, domains, regions, registers. Parameters can take comma separated list of values. E.g., lexicalCategory=noun,adjective;domains=sport. Number of values limited to 5."
          in: path
          name: filters_advanced
          required: true
          schema:
            default: lexicalCategory=Noun;domains=sport
            type: string
        - description: Semicolon separated list of parameters-value pairs (same as filters). Excludes headwords that have any senses in specified exclusion attributes (lexical categories, domains, etc.) from results.
          in: query
          name: exclude
          required: false
          schema:
            type: string
        - description: Semicolon separated list of parameters-value pairs (same as filters). Excludes only those senses of a particular headword that match specified exclusion attributes (lexical categories, domains, etc.) from results but includes the headword if it has other permitted senses.
          in: query
          name: exclude_senses
          required: false
          schema:
            type: string
        - description: Semicolon separated list of parameters-value pairs (same as filters). Excludes a headword only if the primary sense matches the specified exclusion attributes (registers, domains only).
          in: query
          name: exclude_prime_senses
          required: false
          schema:
            type: string
        - description: Parameter to speficy the minimum (>), exact or maximum (<) length of the words required. E.g., >5 - more than 5 chars; <4 - less than 4 chars; >5<10 - from 5 to 10 chars; 3 - exactly 3 chars.
          in: query
          name: word_length
          required: false
          schema:
            default: ">5,<10"
            type: string
        - description: Filter words that start with prefix parameter
          in: query
          name: prefix
          required: false
          schema:
            default: goal
            type: string
        - description: If exact=true wordlist returns a list of entries that exactly matches the search string. Otherwise wordlist lists entries that start with prefix string.
          in: query
          name: exact
          required: false
          schema:
            default: "false"
            enum:
              - "false"
              - "true"
            type: boolean
        - description: Limit the number of results per response. Default and maximum limit is 5000.
          in: query
          name: limit
          required: false
          schema:
            type: string
        - description: Offset the start number of the result.
          in: query
          name: offset
          required: false
          schema:
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Wordlist"
          description: Successful response.
        "400":
          description: disjoint sets of word_length values (eg <3>10); filter has no values; total number of filters > 20; filters and excludes values can not be the same; source_lang and translations can not be same; word_length conflicts with prefix length.
        "404":
          description: |
            No entries is found matching supplied filters or lang or filters is not recognized.
        "500":
          description: |
            Internal Error. An error occurred while processing the data.
      summary: Retrieve list of words for category with advanced options
      tags:
        - Wordlist
  "/wordlist/{source_lang}/{filters_basic}":
    get:
      description: |
        
        Use this to retrieve a [list of words](documentation/glossary?term=wordlist) for particular [domain](documentation/glossary?term=domain), [lexical category](documentation/glossary?term=lexicalcategory), [register](documentation/glossary?term=registers) and/or [region](documentation/glossary?term=regions). View the full list of possible filters using the filters Utility endpoint.  The response only includes [headwords](documentation/glossary?term=headword), not all their possible [inflections](documentation/glossary?term=inflection). If you require a full [wordlist](documentation/glossary?term=wordlist) including [inflected forms](documentation/glossary?term=inflection), contact us and we can help.

          <div id="wordlist"></div>
      parameters:
        - description: IANA language code
          in: path
          name: source_lang
          required: true
          schema:
            enum:
              - en
              - es
              - hi
              - lv
              - sw
              - ta
              - gu
            type: string
        - description: "Semicolon separated list of wordlist parameters, presented as value pairs: LexicalCategory, domains, regions, registers. Parameters can take comma separated list of values. E.g., lexicalCategory=noun,adjective;domains=sport. Number of values limited to 5."
          in: path
          name: filters_basic
          required: true
          schema:
            default: registers=Rare;domains=Art
            type: string
        - description: Limit the number of results per response. Default and maximum limit is 5000.
          in: query
          name: limit
          required: false
          schema:
            type: string
        - description: Offset the start number of the result
          in: query
          name: offset
          required: false
          schema:
            type: string
        - $ref: "#/components/parameters/appId"
        - $ref: "#/components/parameters/appKey"
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/Wordlist"
          description: Successful response.
        "400":
          description: filter has no values; total number of filters > 20.
        "404":
          description: |
            No entries is found matching supplied filters or lang or filters is not recognized.
        "500":
          description: |
            Internal Error. An error occurred while processing the data.
      summary: Retrieve a list of words in a category
      tags:
        - Wordlist
components:
  parameters:
    appId:
      description: App ID Authentication Parameter
      in: header
      name: app_id
      required: true
      schema:
        default: 5037d509
        type: string
      x-data-threescale-name: app_ids
    appKey:
      description: App Key Authentication Parameter
      in: header
      name: app_key
      required: true
      schema:
        default: 4dc1aebaa63721f0f8e79a55e2514bc7
        type: string
      x-data-threescale-name: app_keys
    entriesWordId:
      description: An Entry identifier. Case-sensitive.
      in: path
      name: word_id
      required: true
      schema:
        default: ace
        type: string
    keyValFilters:
      description: Separate filtering conditions using a semicolon. Conditions take values grammaticalFeatures and/or lexicalCategory and are case-sensitive. To list multiple values in single condition divide them with comma.
      in: path
      name: filters
      required: true
      schema:
        default: grammaticalFeatures=singular,past;lexicalCategory=noun
        items:
          pattern: (lexicalCategory|grammaticalFeatures)=.+
          type: string
        type: string
      style: simple
    monolingual-lemmatron-source_lang:
      description: IANA language code
      in: path
      name: source_lang
      required: true
      schema:
        enum:
          - en
          - es
          - hi
          - nso
          - tn
          - zu
          - de
          - pt
        type: string
    monolingual-source_lang:
      description: IANA language code
      in: path
      name: source_lang
      required: true
      schema:
        enum:
          - en
          - es
          - lv
          - hi
          - sw
          - ta
          - gu
          - fr
        type: string
    monolingual-wordlist-source_lang:
      description: IANA language code
      in: path
      name: source_lang
      required: true
      schema:
        enum:
          - en
          - es
          - hi
          - lv
          - sw
          - ta
          - gu
        type: string
    thesaurus-source_lang:
      description: IANA language code
      in: path
      name: source_lang
      required: true
      schema:
        enum:
          - en
        type: string
  schemas:
    ArrayOfRelatedEntries:
      description: A list of written or spoken words
      items:
        additionalProperties: false
        properties:
          domains:
            $ref: "#/components/schemas/arrayofstrings"
          id:
            description: The identifier of the word
            type: string
          language:
            description: IANA language code specifying the language of the word
            type: string
          regions:
            $ref: "#/components/schemas/arrayofstrings"
          registers:
            $ref: "#/components/schemas/arrayofstrings"
          text:
            type: string
        required:
          - text
          - id
        type: object
      minItems: 1
      type: array
    CategorizedTextList:
      description: various types of notes that appear
      items:
        additionalProperties: false
        properties:
          id:
            description: The identifier of the word
            type: string
          text:
            description: A note text
            type: string
          type:
            description: The descriptive category of the text
            type: string
        required:
          - text
          - type
        type: object
      minItems: 1
      type: array
    CrossReferencesList:
      description: A reference to another word that is closely related, might provide additional information about the subject, has a variant spelling or is an abbreviated form of it.
      items:
        additionalProperties: false
        description: cross references of a sense
        properties:
          id:
            description: The word id of cooccurrence
            type: string
          text:
            description: The word of cooccurrence
            type: string
          type:
            description: The type of relation between the two words. Possible values are 'close match', 'related', 'see also', 'variant spelling', and 'abbreviation' in case of crossreferences, or 'pre', 'post' in case of collocates.
            type: string
        required:
          - id
          - text
          - type
        type: object
      minItems: 1
      type: array
    Entry:
      additionalProperties: false
      minProperties: 1
      properties:
        etymologies:
          $ref: "#/components/schemas/arrayofstrings"
        grammaticalFeatures:
          $ref: "#/components/schemas/GrammaticalFeaturesList"
        homographNumber:
          description: Identifies the homograph grouping. The last two digits identify different entries of the same homograph. The first one/two digits identify the homograph number.
          type: string
        notes:
          $ref: "#/components/schemas/CategorizedTextList"
        pronunciations:
          $ref: "#/components/schemas/PronunciationsList"
        senses:
          description: Complete list of senses
          items:
            $ref: "#/components/schemas/Sense"
          minItems: 1
          type: array
        variantForms:
          $ref: "#/components/schemas/VariantFormsList"
      type: object
    ExamplesList:
      description: A list of written or spoken rendering of examples of use of a word or text
      items:
        additionalProperties: false
        properties:
          definitions:
            $ref: "#/components/schemas/arrayofstrings"
          domains:
            $ref: "#/components/schemas/arrayofstrings"
          notes:
            $ref: "#/components/schemas/CategorizedTextList"
          regions:
            $ref: "#/components/schemas/arrayofstrings"
          registers:
            $ref: "#/components/schemas/arrayofstrings"
          senseIds:
            $ref: "#/components/schemas/arrayofstrings"
          text:
            type: string
          translations:
            $ref: "#/components/schemas/TranslationsList"
        required:
          - text
        type: object
      minItems: 1
      type: array
    Filters:
      description: Schema for the Filters endpoint.
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          additionalProperties: false
          description: A mapping of filters available per endpoints.
          minProperties: 1
          properties:
            entries:
              $ref: "#/components/schemas/arrayofstrings"
            inflections:
              $ref: "#/components/schemas/arrayofstrings"
            translations:
              $ref: "#/components/schemas/arrayofstrings"
            wordlist:
              $ref: "#/components/schemas/arrayofstrings"
          type: object
    GrammaticalFeaturesList:
      description: The different forms are correlated with meanings or functions which we text as 'features'
      items:
        additionalProperties: false
        properties:
          text:
            type: string
          type:
            type: string
        required:
          - text
          - type
        type: object
      minItems: 1
      type: array
    HeadwordEntry:
      additionalProperties: false
      description: Description of a word
      properties:
        id:
          description: The identifier of a word
          type: string
        language:
          description: IANA language code
          type: string
        lexicalEntries:
          description: A grouping of various senses in a specific language, and a lexical category that relates to a word
          items:
            $ref: "#/components/schemas/lexicalEntry"
          minItems: 1
          type: array
        pronunciations:
          $ref: "#/components/schemas/PronunciationsList"
        type:
          description: The json object type. Could be 'headword', 'inflection' or 'phrase'
          type: string
        word:
          description: A given written or spoken realisation of a an entry, lowercased.
          type: string
      required:
        - id
        - language
        - lexicalEntries
        - word
      type: object
    HeadwordLemmatron:
      additionalProperties: false
      description: Description of an inflected form of a word
      properties:
        id:
          description: The identifier of a word
          type: string
        language:
          description: IANA language code
          type: string
        lexicalEntries:
          description: A grouping of various senses in a specific language, and a lexical category that relates to a word
          items:
            $ref: "#/components/schemas/LemmatronLexicalEntry"
          minItems: 1
          type: array
        type:
          description: The json object type. Could be 'headword', 'inflection' or 'phrase'
          type: string
        word:
          description: A given written or spoken realisation of a an entry, lowercased.
          type: string
      required:
        - id
        - language
        - lexicalEntries
        - word
      type: object
    HeadwordThesaurus:
      additionalProperties: false
      description: description of thesaurus information of a word
      properties:
        id:
          description: The identifier of a word
          type: string
        language:
          description: IANA language code
          type: string
        lexicalEntries:
          description: A grouping of various senses in a specific language, and a lexical category that relates to a word
          items:
            $ref: "#/components/schemas/ThesaurusLexicalEntry"
          minItems: 1
          type: array
        type:
          description: The json object type. Could be 'headword', 'inflection' or 'phrase'
          type: string
        word:
          description: A given written or spoken realisation of a an entry, lowercased.
          type: string
      required:
        - word
        - id
        - language
        - lexicalEntries
      type: object
    InflectionsList:
      description: A grouping of the modifications of a word to express different grammatical categories
      items:
        additionalProperties: false
        properties:
          id:
            description: The identifier of the word
            type: string
          text:
            type: string
        required:
          - text
          - id
        type: object
      minItems: 1
      type: array
    Languages:
      description: Schema for the languages endpoint.
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A list of languages available.
          items:
            additionalProperties: false
            minProperties: 1
            properties:
              region:
                description: Name of region.
                type: string
              source:
                description: Name of source dictionary.
                type: string
              sourceLanguage:
                description: Source language of the results
                properties:
                  id:
                    description: IANA language code
                    type: string
                  language:
                    description: Language label.
                    type: string
                type: object
              targetLanguage:
                description: Translation language of the results
                properties:
                  id:
                    description: IANA language code
                    type: string
                  language:
                    description: Language label.
                    type: string
                type: object
              type:
                description: whether monolingual or bilingual.
                enum:
                  - monolingual
                  - bilingual
                type: string
            type: object
          minItems: 1
          type: array
      type: object
    Lemmatron:
      description: Schema for the inflections endpoint.
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A list of inflections matching a given word
          items:
            $ref: "#/components/schemas/HeadwordLemmatron"
          minItems: 1
          type: array
      type: object
    LemmatronLexicalEntry:
      additionalProperties: false
      description: Description of an entry for a particular part of speech and grammatical features
      properties:
        grammaticalFeatures:
          $ref: "#/components/schemas/GrammaticalFeaturesList"
        inflectionOf:
          $ref: "#/components/schemas/InflectionsList"
        language:
          description: IANA language code
          type: string
        lexicalCategory:
          description: A linguistic category of words (or more precisely lexical items), generally defined by the syntactic or morphological behaviour of the lexical item in question, such as noun or verb
          type: string
        text:
          description: A given written or spoken realisation of a an entry.
          type: string
      required:
        - inflectionOf
        - language
        - lexicalCategory
        - text
      type: object
    NgramsResult:
      description: Schema for corpus ngrams.
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A list of found ngrams along with their frequencies
          items:
            additionalProperties: true
            description: Ngrams matching the given options
            properties:
              frequency:
                description: The number of times the ngram (a sequence of n words) appears in the corpus
                type: integer
              tokens:
                description: A list of tokens
                items:
                  type: string
                minItems: 1
                type: array
            required:
              - tokens
              - frequency
            type: object
          minItems: 0
          type: array
      type: object
    PronunciationsList:
      description: A list of possible pronunciations of a word
      items:
        additionalProperties: false
        description: A grouping of pronunciation information
        minProperties: 1
        properties:
          audioFile:
            description: The URL of the sound file
            type: string
          dialects:
            $ref: "#/components/schemas/arrayofstrings"
          phoneticNotation:
            description: The alphabetic system used to display the phonetic spelling
            type: string
          phoneticSpelling:
            description: Phonetic spelling is the representation of vocal sounds which express pronunciations of words. It is a system of spelling in which each letter represents invariably the same spoken sound
            type: string
          regions:
            $ref: "#/components/schemas/arrayofstrings"
        type: object
      minItems: 1
      type: array
    Regions:
      description: Schema for region endpoint.
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          additionalProperties:
            $ref: "#/components/schemas/arrayofstrings"
          description: A mapping of regions available.
          type: object
    RetrieveEntry:
      description: Schema for the 'entries' endpoints
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A list of entries and all the data related to them
          items:
            $ref: "#/components/schemas/HeadwordEntry"
          minItems: 1
          type: array
      type: object
    Sense:
      additionalProperties: false
      description: A lexical sense represents the lexical meaning of a lexical entry when interpreted as referring to the corresponding ontology element
      minProperties: 1
      properties:
        crossReferenceMarkers:
          $ref: "#/components/schemas/arrayofstrings"
        crossReferences:
          $ref: "#/components/schemas/CrossReferencesList"
        definitions:
          $ref: "#/components/schemas/arrayofstrings"
        domains:
          $ref: "#/components/schemas/arrayofstrings"
        examples:
          $ref: "#/components/schemas/ExamplesList"
        id:
          description: The id of the sense that is required for the delete procedure
          type: string
        notes:
          $ref: "#/components/schemas/CategorizedTextList"
        pronunciations:
          $ref: "#/components/schemas/PronunciationsList"
        regions:
          $ref: "#/components/schemas/arrayofstrings"
        registers:
          $ref: "#/components/schemas/arrayofstrings"
        short_definitions:
          $ref: "#/components/schemas/arrayofstrings"
        subsenses:
          description: Ordered list of subsenses of a sense
          items:
            $ref: "#/components/schemas/Sense"
          minItems: 1
          type: array
        thesaurusLinks:
          description: Ordered list of links to the Thesaurus Dictionary
          items:
            $ref: "#/components/schemas/thesaurusLink"
          minItems: 1
          type: array
        translations:
          $ref: "#/components/schemas/TranslationsList"
        variantForms:
          $ref: "#/components/schemas/VariantFormsList"
      type: object
    SentencesEntry:
      additionalProperties: false
      description: Description of a word
      properties:
        id:
          description: The identifier of a word
          type: string
        language:
          description: IANA language code
          type: string
        lexicalEntries:
          description: A grouping of various senses in a specific language, and a lexical category that relates to a word
          items:
            $ref: "#/components/schemas/SentencesLexicalEntry"
          minItems: 1
          type: array
        type:
          description: The json object type. Could be 'headword', 'inflection' or 'phrase'
          type: string
        word:
          description: A given written or spoken realisation of a an entry, lowercased.
          type: string
      required:
        - id
        - language
        - lexicalEntries
        - word
      type: object
    SentencesLexicalEntry:
      additionalProperties: false
      description: Description of an entry for a particular part of speech
      properties:
        grammaticalFeatures:
          $ref: "#/components/schemas/GrammaticalFeaturesList"
        language:
          description: IANA language code
          type: string
        lexicalCategory:
          description: A linguistic category of words (or more precisely lexical items), generally defined by the syntactic or morphological behaviour of the lexical item in question, such as noun or verb
          type: string
        sentences:
          $ref: "#/components/schemas/ExamplesList"
        text:
          description: A given written or spoken realisation of a an entry.
          type: string
      required:
        - language
        - sentences
        - text
      type: object
    SentencesResults:
      description: Schema for the 'sentences' endpoint
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A list of entries and all the data related to them
          items:
            $ref: "#/components/schemas/SentencesEntry"
          minItems: 1
          type: array
      type: object
    StatsWordResult:
      description: Schema for lexi-stats results for a word/trueCase/lemma/lexicalCategory returned as a frequency
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        result:
          additionalProperties: true
          description: Frequency information for a given entity
          properties:
            frequency:
              description: The number of times a word appears in the entire corpus
              type: integer
            lemma:
              description: A lemma of the word (e.g., wordforms "lay", "laid" and "laying" have all lemma "lay")
              type: string
            lexicalCategory:
              description: A lexical category such as 'verb' or 'noun'
              type: string
            matchCount:
              description: The number of database records that matched the query params (stated frequency is the sum of the individual frequencies)
              type: integer
            normalizedFrequency:
              description: The number of times a word appears on average in 1 million words
              type: integer
            trueCase:
              description: A given written realisation of a an entry (e.g., "lay") usually lower case
              type: string
            wordform:
              description: A given written realisation of a an entry (e.g., "Lay") preserving case
              type: string
          required:
            - frequency
            - normalizedFrequency
            - matchCount
          type: object
      type: object
    StatsWordResultList:
      description: Schema for lexi-stats results for a word/trueCase/lemma/lexicalCategory returned as a list of frequencies per wordform-trueCase-lemma-lexicalCategory entry.
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A list of found words along with their frequencies
          items:
            additionalProperties: true
            description: Statistical information about a word
            properties:
              frequency:
                description: The number of times a word appears in the entire corpus
                type: integer
              lemma:
                description: A lemma of the word.
                type: string
              lexicalCategory:
                description: A lexical category such as 'verb' or 'noun'
                type: string
              normalizedFrequency:
                description: The number of times a word appears on average in 1 million words
                type: integer
              trueCase:
                description: A given written realisation of a an entry (e.g., "lay") usually lower case
                type: string
              wordform:
                description: A given written realisation of a an entry (e.g., "lay") preserving case
                type: string
            required:
              - wordform
              - trueCase
              - lemma
              - lexicalCategory
              - frequency
              - normalizedFrequency
            type: object
          minItems: 0
          type: array
      type: object
    SynonymsAntonyms:
      items:
        additionalProperties: false
        properties:
          domains:
            $ref: "#/components/schemas/arrayofstrings"
          id:
            type: string
          language:
            type: string
          regions:
            $ref: "#/components/schemas/arrayofstrings"
          registers:
            $ref: "#/components/schemas/arrayofstrings"
          text:
            type: string
        required:
          - id
          - text
        type: object
      minItems: 1
      type: array
    Thesaurus:
      description: Schema for thesaurus endpoint
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A list of found synonyms or antonyms
          items:
            $ref: "#/components/schemas/HeadwordThesaurus"
          minItems: 1
          type: array
      type: object
    ThesaurusEntry:
      additionalProperties: false
      minProperties: 1
      properties:
        homographNumber:
          description: Identifies the homograph grouping. The last two digits identify different entries of the same homograph. The first one/two digits identify the homograph number.
          type: string
        senses:
          description: Complete list of senses
          items:
            $ref: "#/components/schemas/ThesaurusSense"
          minItems: 1
          type: array
        variantForms:
          $ref: "#/components/schemas/VariantFormsList"
      type: object
    ThesaurusLexicalEntry:
      additionalProperties: false
      description: Description of an entry for a particular part of speech
      properties:
        entries:
          items:
            $ref: "#/components/schemas/ThesaurusEntry"
          minItems: 1
          type: array
        language:
          description: IANA language code
          type: string
        lexicalCategory:
          description: A linguistic category of words (or more precisely lexical items), generally defined by the syntactic or morphological behaviour of the lexical item in question, such as noun or verb
          type: string
        text:
          description: A given written or spoken realisation of a an entry.
          type: string
        variantForms:
          $ref: "#/components/schemas/VariantFormsList"
      required:
        - language
        - lexicalCategory
        - text
      type: object
    ThesaurusSense:
      additionalProperties: false
      description: A lexical sense represents the lexical meaning of a lexical entry when interpreted as referring to the corresponding ontology element
      minProperties: 1
      properties:
        antonyms:
          $ref: "#/components/schemas/SynonymsAntonyms"
        domains:
          $ref: "#/components/schemas/arrayofstrings"
        examples:
          $ref: "#/components/schemas/ExamplesList"
        id:
          description: The id of the sense that is required for the delete procedure
          type: string
        regions:
          $ref: "#/components/schemas/arrayofstrings"
        registers:
          $ref: "#/components/schemas/arrayofstrings"
        subsenses:
          description: subsenses of word
          items:
            $ref: "#/components/schemas/ThesaurusSense"
          minItems: 1
          type: array
        synonyms:
          $ref: "#/components/schemas/SynonymsAntonyms"
      type: object
    TranslationsList:
      description: A list of written or spoken rendering of the meaning of a word or text in another language(s)
      items:
        additionalProperties: false
        properties:
          domains:
            $ref: "#/components/schemas/arrayofstrings"
          grammaticalFeatures:
            $ref: "#/components/schemas/GrammaticalFeaturesList"
          language:
            description: IANA language code specifying the language of the translation
            type: string
          notes:
            $ref: "#/components/schemas/CategorizedTextList"
          regions:
            $ref: "#/components/schemas/arrayofstrings"
          registers:
            $ref: "#/components/schemas/arrayofstrings"
          text:
            type: string
        required:
          - text
          - language
        type: object
      minItems: 1
      type: array
    UtilityLabels:
      description: Schema for lexicalcategories, registers utility endpoints.
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          additionalProperties:
            description: the list of labels for an object. Every object can be a lexical category, or a register, or a domain.
            properties:
              en:
                description: Label in English
                type: string
            type: object
          description: Mapping of labels available.
          type: object
    VariantFormsList:
      description: Various words that are used interchangeably depending on the context, e.g 'aluminium' and 'aluminum'
      items:
        additionalProperties: false
        properties:
          regions:
            $ref: "#/components/schemas/arrayofstrings"
          text:
            type: string
        required:
          - text
        type: object
      minItems: 1
      type: array
    Wordlist:
      description: Schema for wordlist endpoint.
      properties:
        metadata:
          description: Additional Information provided by OUP
          type: object
        results:
          description: A list of found words
          items:
            additionalProperties: true
            description: Description of found word
            properties:
              id:
                description: The identifier of a word
                type: string
              matchString:
                nullable: true
                type: string
              matchType:
                type: string
              region:
                description: Name of region.
                type: string
              word:
                description: A given written or spoken realisation of a an entry, lowercased.
                type: string
            required:
              - id
              - word
            type: object
          minItems: 0
          type: array
      type: object
    arrayofstrings:
      items:
        type: string
      type: array
    lexicalEntry:
      additionalProperties: false
      description: Description of an entry for a particular part of speech
      properties:
        derivativeOf:
          $ref: "#/components/schemas/ArrayOfRelatedEntries"
        derivatives:
          $ref: "#/components/schemas/ArrayOfRelatedEntries"
        entries:
          items:
            $ref: "#/components/schemas/Entry"
          minItems: 1
          type: array
        grammaticalFeatures:
          $ref: "#/components/schemas/GrammaticalFeaturesList"
        language:
          description: IANA language code
          type: string
        lexicalCategory:
          description: A linguistic category of words (or more precisely lexical items), generally defined by the syntactic or morphological behaviour of the lexical item in question, such as noun or verb
          type: string
        notes:
          $ref: "#/components/schemas/CategorizedTextList"
        pronunciations:
          $ref: "#/components/schemas/PronunciationsList"
        text:
          description: A given written or spoken realisation of a an entry.
          type: string
        variantForms:
          $ref: "#/components/schemas/VariantFormsList"
      required:
        - language
        - lexicalCategory
        - text
      type: object
    thesaurusLink:
      description: Link to a sense of a specific entry in the thesaurus Dictionary
      properties:
        entry_id:
          description: identifier of a word
          type: string
        sense_id:
          description: identifier of a sense
          type: string
      required:
        - entry_id
        - sense_id
      type: object
