Cloudmersive

Cloudmersive Recognize API

Recognize operations of the Cloudmersive Image Recognition and Processing API — 11 operation(s) served from https://api.cloudmersive.com and authenticated with the Apikey header (merged with the same tag in the Voice Recognition and Speech API). One Cloudmersive API key grants access to every API in the portfolio.

GitHub OpenAPI

Operations 11

POST /image/recognize/similarity/compare Compare two images for similarity #
POST /image/recognize/similarity/hash Generate a perceptual image hash #
POST /image/recognize/similarity/hash/distance Calculates the similarity between two perceptual image hashes #
POST /image/recognize/describe Describe an image in natural language #
POST /image/recognize/find/symbol Find the location of a symbol in an image #
POST /image/recognize/detect-vehicle-license-plates Detect vehicle license plates in an image #
POST /image/recognize/detect-document/unskew Detect and unskew a photo of a document #
POST /image/recognize/detect-text/large Detect large text in a photo #
POST /image/recognize/detect-text/fine Detect fine text in a photo of a document #
POST /speech/recognize/file Recognize audio input as text using Advanced AI #
POST /speech/recognize/file/advanced Recognize audio input as text using Advanced AI with high-accuracy word-level… #

Documentation

📖
Documentation
https://api.cloudmersive.com/docs/image.asp
📖
APIReference
https://api-console.cloudmersive.com/swagger/index.html?urls.primaryName=Image%20Recognition%20and%20Processing%20API

Specifications

⚙
OpenAPI
https://artifacts.apis.io/cloudmersive/openapi/cloudmersive-recognize-api-openapi.yml
⚙
OpenAPI
https://api.cloudmersive.com/image/docs/v1/swagger

Schemas & Data

📊
JSONSchema
https://artifacts.apis.io/cloudmersive/json-schema/cloudmersive-find-symbol-result-schema.json
📊
JSONSchema
https://artifacts.apis.io/cloudmersive/json-schema/cloudmersive-speech-recognition-result-advanced-schema.json
📊
JSONSchema
https://artifacts.apis.io/cloudmersive/json-schema/cloudmersive-image-description-response-schema.json
📊
JSONSchema
https://artifacts.apis.io/cloudmersive/json-schema/cloudmersive-vehicle-license-plate-detection-result-schema.json
📊
JSONSchema
https://artifacts.apis.io/cloudmersive/json-schema/cloudmersive-fine-text-detection-result-schema.json
📊
JSONSchema
https://artifacts.apis.io/cloudmersive/json-schema/cloudmersive-text-detection-result-schema.json

Work with this as data

Every API here is available over the APIs.io API and to AI agents over MCP.

MCP server

One button, every client — Claude, Cursor, VS Code and the rest.

https://apis.io/mcp

Tools for apis

7 MCP tools reach this
  • find_apisBrowse and filter every API in the catalog.
  • get_api_artifactsOne API's artifacts, grouped by type.
  • get_openapiThe primary OpenAPI for this API.
  • find_similar_apisAPIs that look like this one.
  • apis_io_searchSTART HERE — APIs, providers and tags for one query, each with its total.
  • resolveTurn a domain, URL or GitHub org into the provider it belongs to.
  • find_cohortsEvery scored population of providers in the catalog.
All 92 tools →

Call it yourself

curl for this page
This API 
curl "https://apis.io/api/v1/apis/cloudmersive:cloudmersive-recognize-api"
All apis 
curl "https://apis.io/api/v1/apis?limit=25"

Calls without X-API-Key need no key. Calls with it need a paid plan — get a key.

Get an API key

Free tier, no form to fill in. Signing in shares your email address with us — we store it to create your key and to recognise you if you sign in with another provider. See our Privacy Policy and Terms.

GitHub Google LinkedIn

A second provider on the same verified email joins the account you already have.

OpenAPI Specification

cloudmersive-recognize-api-openapi.yml Raw ↑ 
openapi: 3.2.0
info:
  title: Cloudmersive Recognize API
  version: v1
  description: 'Operations tagged Recognize across 2 of this provider''s published API definitions: cloudmersive-image-openapi.json, cloudmersive-speech-openapi.json. Each path carries the servers of the definition it was published in.'
servers:
- url: http://localhost
- url: https://testapi.cloudmersive.com
tags:
- name: Recognize
paths:
  /image/recognize/similarity/compare:
    post:
      tags:
      - Recognize
      summary: Compare two images for similarity
      description: Generates an image similarity score using Deep Learning between 0.0 and 1.0, values closer to 1.0 indicate greater similarity
      operationId: Recognize_SimilarityCompare
      parameters:
      - name: recognitionMode
        in: header
        description: Optional, specify the recognition mode; possible values are Normal, Basic and Advanced.  Default is Normal.
        required: false
        schema:
          type: string
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                format: byte
                type: string
            text/json:
              schema:
                format: byte
                type: string
            application/xml:
              schema:
                format: byte
                type: string
            text/xml:
              schema:
                format: byte
                type: string
      security:
      - Apikey: []
      requestBody:
        content:
          multipart/form-data:
            schema:
              type: object
              properties:
                baseImage:
                  type: string
                  description: Image file to compare against.  Common file formats such as PNG, JPEG are supported.
                  format: binary
                comparisonImage:
                  type: string
                  description: Image to compare to the base image.
                  format: binary
              required:
              - baseImage
              - comparisonImage
    servers:
    - url: http://localhost
  /image/recognize/similarity/hash:
    post:
      tags:
      - Recognize
      summary: Generate a perceptual image hash
      description: Generates a hash value for the image; hash values that are closer together in terms of Hamming Distance are more similar.
      operationId: Recognize_SimilarityHash
      parameters:
      - name: recognitionMode
        in: header
        description: Optional, specify the recognition mode; possible values are Normal, Basic and Advanced.  Default is Normal.
        required: false
        schema:
          type: string
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ImageSimilarityHashResponse'
            text/json:
              schema:
                $ref: '#/components/schemas/ImageSimilarityHashResponse'
            application/xml:
              schema:
                $ref: '#/components/schemas/ImageSimilarityHashResponse'
            text/xml:
              schema:
                $ref: '#/components/schemas/ImageSimilarityHashResponse'
      security:
      - Apikey: []
      requestBody:
        content:
          multipart/form-data:
            schema:
              type: object
              properties:
                imageFile:
                  type: string
                  description: Image file to perform the operation on.  Common file formats such as PNG, JPEG are supported.
                  format: binary
              required:
              - imageFile
    servers:
    - url: http://localhost
  /image/recognize/similarity/hash/distance:
    post:
      tags:
      - Recognize
      summary: Calculates the similarity between two perceptual image hashes
      description: Calculates the similarity between two perceptual image hashes by computing the Hamming Distance between them.
      operationId: Recognize_SimilarityHashDistance
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ImageSimilarityHashDistanceResponse'
            text/json:
              schema:
                $ref: '#/components/schemas/ImageSimilarityHashDistanceResponse'
            application/xml:
              schema:
                $ref: '#/components/schemas/ImageSimilarityHashDistanceResponse'
            text/xml:
              schema:
                $ref: '#/components/schemas/ImageSimilarityHashDistanceResponse'
      security:
      - Apikey: []
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ImageSimilarityHashDistanceRequest'
          text/json:
            schema:
              $ref: '#/components/schemas/ImageSimilarityHashDistanceRequest'
          application/xml:
            schema:
              $ref: '#/components/schemas/ImageSimilarityHashDistanceRequest'
          text/xml:
            schema:
              $ref: '#/components/schemas/ImageSimilarityHashDistanceRequest'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/ImageSimilarityHashDistanceRequest'
        required: true
    servers:
    - url: http://localhost
  /image/recognize/describe:
    post:
      tags:
      - Recognize
      summary: Describe an image in natural language
      description: Generate an English language text description of the image as a sentence.
      operationId: Recognize_Describe
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ImageDescriptionResponse'
            text/json:
              schema:
                $ref: '#/components/schemas/ImageDescriptionResponse'
            application/xml:
              schema:
                $ref: '#/components/schemas/ImageDescriptionResponse'
            text/xml:
              schema:
                $ref: '#/components/schemas/ImageDescriptionResponse'
      security:
      - Apikey: []
      requestBody:
        content:
          multipart/form-data:
            schema:
              type: object
              properties:
                imageFile:
                  type: string
                  description: Image file to perform the operation on.  Common file formats such as PNG, JPEG are supported.
                  format: binary
              required:
              - imageFile
    servers:
    - url: http://localhost
  /image/recognize/find/symbol:
    post:
      tags:
      - Recognize
      summary: Find the location of a symbol in an image
      description: Determine if an image contains a symbol, and if so, the location of that symbol in the image.
      operationId: Recognize_FindSymbol
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/FindSymbolResult'
            text/json:
              schema:
                $ref: '#/components/schemas/FindSymbolResult'
            application/xml:
              schema:
                $ref: '#/components/schemas/FindSymbolResult'
            text/xml:
              schema:
                $ref: '#/components/schemas/FindSymbolResult'
      security:
      - Apikey: []
      requestBody:
        content:
          multipart/form-data:
            schema:
              type: object
              properties:
                inputImage:
                  type: string
                  description: Image file to search through for the target image.
                  format: binary
                targetImage:
                  type: string
                  description: Image to find in the input image.
                  format: binary
              required:
              - inputImage
              - targetImage
    servers:
    - url: http://localhost
  /image/recognize/detect-vehicle-license-plates:
    post:
      tags:
      - Recognize
      summary: Detect vehicle license plates in an image
      description: Identify the position, and size, and content of vehicle license plates in an image. License plates should be within 15-20 degrees on-axis to the camera. Supported image formats are JPG, PNG and BMP.
      operationId: Recognize_DetectVehicleLicensePlates
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/VehicleLicensePlateDetectionResult'
            text/json:
              schema:
                $ref: '#/components/schemas/VehicleLicensePlateDetectionResult'
            application/xml:
              schema:
                $ref: '#/components/schemas/VehicleLicensePlateDetectionResult'
            text/xml:
              schema:
                $ref: '#/components/schemas/VehicleLicensePlateDetectionResult'
      security:
      - Apikey: []
      requestBody:
        content:
          multipart/form-data:
            schema:
              type: object
              properties:
                imageFile:
                  type: string
                  description: Image file to perform the operation on.  Common file formats such as PNG, JPEG are supported.
                  format: binary
              required:
              - imageFile
    servers:
    - url: http://localhost
  /image/recognize/detect-document/unskew:
    post:
      tags:
      - Recognize
      summary: Detect and unskew a photo of a document
      description: Detect and unskew a photo of a document (e.g. taken on a cell phone) into a perfectly square image. Great for document scanning applications; once unskewed, this image is perfect for converting to PDF using the Convert API or optical character recognition using the OCR API.
      operationId: Recognize_DetectAndUnskewDocument
      parameters:
      - name: PostProcessingEffect
        in: header
        description: Optional, post-processing effects to apply to the email, default is None.  Possible values are None and BlackAndWhite (force the image into a black and white view to aid in OCR operations).
        required: false
        schema:
          type: string
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                format: byte
                type: string
            text/json:
              schema:
                format: byte
                type: string
            application/xml:
              schema:
                format: byte
                type: string
            text/xml:
              schema:
                format: byte
                type: string
      security:
      - Apikey: []
      requestBody:
        content:
          multipart/form-data:
            schema:
              type: object
              properties:
                imageFile:
                  type: string
                  description: Image file to perform the operation on.  Common file formats such as PNG, JPEG are supported.
                  format: binary
              required:
              - imageFile
    servers:
    - url: http://localhost
  /image/recognize/detect-text/large:
    post:
      tags:
      - Recognize
      summary: Detect large text in a photo
      description: Identify the position, and size of large text within a photograph. Identify the location of large text in a photo - such as signs, titles, etc. and other forms of large, low-density text. Not suitable for high-density text (e.g. scans of documents, receipts, etc.) for OCR purposes - for OCR, please see our Deep Learning OCR APIs.
      operationId: Recognize_DetectTextLarge
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TextDetectionResult'
            text/json:
              schema:
                $ref: '#/components/schemas/TextDetectionResult'
            application/xml:
              schema:
                $ref: '#/components/schemas/TextDetectionResult'
            text/xml:
              schema:
                $ref: '#/components/schemas/TextDetectionResult'
      security:
      - Apikey: []
      requestBody:
        content:
          multipart/form-data:
            schema:
              type: object
              properties:
                imageFile:
                  type: string
                  description: Image file to perform the operation on.  Common file formats such as PNG, JPEG are supported.
                  format: binary
              required:
              - imageFile
    servers:
    - url: http://localhost
  /image/recognize/detect-text/fine:
    post:
      tags:
      - Recognize
      summary: Detect fine text in a photo of a document
      description: Identify the position, and size of small/fine text within a photograph of a document. Identify the location of small text in a photo - such as words and other forms of high density text. Can be used on a scan of a document or a photograph (e.g. smartphone camera) of a document, page or receipt. For OCR purposes - please see our Deep Learning OCR APIs.
      operationId: Recognize_DetectTextFine
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/FineTextDetectionResult'
            text/json:
              schema:
                $ref: '#/components/schemas/FineTextDetectionResult'
            application/xml:
              schema:
                $ref: '#/components/schemas/FineTextDetectionResult'
            text/xml:
              schema:
                $ref: '#/components/schemas/FineTextDetectionResult'
      security:
      - Apikey: []
      requestBody:
        content:
          multipart/form-data:
            schema:
              type: object
              properties:
                imageFile:
                  type: string
                  description: Image file to perform the operation on.  Common file formats such as PNG, JPEG are supported.
                  format: binary
              required:
              - imageFile
    servers:
    - url: http://localhost
  /speech/recognize/file:
    post:
      tags:
      - Recognize
      summary: Recognize audio input as text using Advanced AI
      description: Uses advanced AI to convert input audio to text. Supports WAV, MP3, M4A, FLAC, OGG, and WMA formats. Consumes 1 API call per second of audio in Fast mode, 5 API calls per second in Normal mode, and 10 API calls per second in Advanced mode.
      parameters:
      - in: header
        name: languageCode
        description: ISO 639-3 three-letter language code (e.g. eng, spa, fra). Empty for auto-detect.
        schema:
          type: string
          default: ''
      - in: header
        name: recognitionMode
        description: 'Recognition mode: Fast, Normal (default), or Advanced. Advanced is only available on Private Cloud and Managed Instance deployments.'
        schema:
          type: string
          default: Normal
      responses:
        '200':
          description: OK
          content:
            text/plain:
              schema:
                $ref: '#/components/schemas/SpeechRecognitionResult'
            application/json:
              schema:
                $ref: '#/components/schemas/SpeechRecognitionResult'
            text/json:
              schema:
                $ref: '#/components/schemas/SpeechRecognitionResult'
      requestBody:
        content:
          multipart/form-data:
            schema:
              type: object
              properties:
                speechFile:
                  type: string
                  description: Speech file to perform the operation on. Common file formats such as WAV, MP3, M4A, FLAC, OGG, WMA are supported.
                  format: binary
              required:
              - speechFile
      security:
      - Apikey: []
      operationId: postSpeechRecognizeFile
      x-operation-id-source: derived
    servers:
    - url: https://testapi.cloudmersive.com
  /speech/recognize/file/advanced:
    post:
      tags:
      - Recognize
      summary: Recognize audio input as text using Advanced AI with high-accuracy word-level…
      description: 'Higher-accuracy variant of /speech/recognize/file. Uses advanced

        alignment for token timestamps.

        Supports WAV, MP3, M4A, FLAC, OGG, and WMA formats.'
      parameters:
      - in: header
        name: languageCode
        description: ISO 639-3 three-letter language code (e.g. eng, spa, fra). Empty for auto-detect.
        schema:
          type: string
          default: ''
      - in: header
        name: recognitionMode
        description: 'Recognition mode: Fast, Normal (default), or Advanced. Advanced is only available on Private Cloud and Managed Instance deployments.'
        schema:
          type: string
          default: Normal
      responses:
        '200':
          description: OK
          content:
            text/plain:
              schema:
                $ref: '#/components/schemas/SpeechRecognitionResultAdvanced'
            application/json:
              schema:
                $ref: '#/components/schemas/SpeechRecognitionResultAdvanced'
            text/json:
              schema:
                $ref: '#/components/schemas/SpeechRecognitionResultAdvanced'
      requestBody:
        content:
          multipart/form-data:
            schema:
              type: object
              properties:
                speechFile:
                  type: string
                  description: Speech file to perform the operation on. Common file formats such as WAV, MP3, M4A, FLAC, OGG, WMA are supported.
                  format: binary
              required:
              - speechFile
      security:
      - Apikey: []
      operationId: postSpeechRecognizeFileAdvanced
      x-operation-id-source: derived
    servers:
    - url: https://testapi.cloudmersive.com
components:
  schemas:
    DetectedLicensePlate:
      description: License plate found in the image
      type: object
      properties:
        LicensePlateText_BestMatch:
          description: Text from the license plate, highest-confidence result
          type: string
        LicensePlateText_RunnerUp:
          description: Alternate text from the license plate, based on second-highest-confidence result
          type: string
        LocationX:
          format: int32
          description: X location of the left edge of the license plate, starting from the left edge of the photo (X = 0)
          type: integer
        LocationY:
          format: int32
          description: Y location of the top edge of the license plate, starting from the top edge of the photo (Y = 0)
          type: integer
        Width:
          format: int32
          description: Width of the license plate's location in pixels
          type: integer
        Height:
          format: int32
          description: Height of the license plate's location in pixels
          type: integer
        LicensePlateRecognitionConfidenceLevel:
          format: double
          description: Confidence score on a range of 0.0 - 1.0 of the accuracy of the detected license plate, with higher scores being better; values about 0.75 are high confidence
          type: number
    FineTextItem:
      description: Individual instance of text occuring in an image; one piece of text
      type: object
      properties:
        DetectedText:
          description: Detected text in the image
          type: string
        TopLeftX:
          format: int32
          description: X coordinate of the top/left text location; 0 represents the left edge of the input image
          type: integer
        TopLeftY:
          format: int32
          description: Y coordinate of the top/left text location; 0 represents the top edge of the input image
          type: integer
        TopRightX:
          format: int32
          description: X coordinate of the top/right text location; 0 represents the left edge of the input image
          type: integer
        TopRightY:
          format: int32
          description: Y coordinate of the top/right text location; 0 represents the top edge of the input image
          type: integer
        BottomLeftX:
          format: int32
          description: X coordinate of the bottom/left text location; 0 represents the left edge of the input image
          type: integer
        BottomLeftY:
          format: int32
          description: Y coordinate of the bottom/left text location; 0 represents the top edge of the input image
          type: integer
        BottomRightX:
          format: int32
          description: X coordinate of the bottom/right text location; 0 represents the left edge of the input image
          type: integer
        BottomRightY:
          format: int32
          description: Y coordinate of the bottom/right text location; 0 represents the top edge of the input image
          type: integer
        Width:
          format: int32
          description: Width in pixels of the text
          type: integer
        Height:
          format: int32
          description: Height in pixels of the text
          type: integer
        Angle:
          format: double
          description: Rotation Angle in radians of the text
          type: number
    ImageSimilarityHashDistanceRequest:
      description: Request to compute the similarity between two image hashes
      type: object
      properties:
        ImageHash1:
          description: Image hash computed using Cloudmersive Image Hashing API
          type: string
        ImageHash2:
          description: Image hash computed using Cloudmersive Image Hashing API
          type: string
    VehicleLicensePlateDetectionResult:
      description: Result of detecting vehicle license plates in an image
      type: object
      properties:
        Successful:
          description: Was the image processed successfully?
          type: boolean
        DetectedLicensePlates:
          description: License plates found in the image
          type: array
          items:
            $ref: '#/components/schemas/DetectedLicensePlate'
        DetectedLicensePlateCount:
          format: int32
          description: The number of license plates detected in the image
          type: integer
    FineTextDetectionResult:
      description: Result of an operation to detect text in a photo
      type: object
      properties:
        Successful:
          description: True if the operation was successful, false otherwise
          type: boolean
        TextItems:
          description: Text items found in the input image
          type: array
          items:
            $ref: '#/components/schemas/FineTextItem'
        TextItemsCount:
          format: int32
          description: Count of text items found in the input image
          type: integer
    TextDetectionResult:
      description: Result of an operation to detect text in a photo
      type: object
      properties:
        Successful:
          description: True if the operation was successful, false otherwise
          type: boolean
        TextItems:
          description: Text items found in the input image
          type: array
          items:
            $ref: '#/components/schemas/TextItem'
        TextItemsCount:
          format: int32
          description: Count of text items found in the input image
          type: integer
    FindSymbolResult:
      description: Result of a find symbol operation on an input image
      type: object
      properties:
        Successful:
          description: True if successful, false otherwise
          type: boolean
        MatchScore:
          format: double
          description: Score between 0.0 and 1.0 that measures how closely the symbol matched; scores above 0.2 are good
          type: number
        XLeft:
          format: int32
          description: X location of the left edge of the found location in pixels
          type: integer
        YTop:
          format: int32
          description: Y location of the top edge of the found location in pixels
          type: integer
        Width:
          format: int32
          description: Width of the found location in pixels
          type: integer
        Height:
          format: int32
          description: Height of the found location in pixels
          type: integer
    ImageSimilarityHashResponse:
      description: Result of performing an image hash operation
      type: object
      properties:
        Successful:
          description: True if successful, false otherwise
          type: boolean
        ImageHash:
          description: String representing image perceptual hash value; values with smaller Hamming Distances are more similar than ones with large Hamming Distances
          type: string
    ImageSimilarityHashDistanceResponse:
      description: Result of computing the similarity between two image hashes
      type: object
      properties:
        Successful:
          description: True if successful, false otherwise
          type: boolean
        ImageSimilarityScore:
          format: double
          description: Similarity score between 0.0 and 1.0, with 1.0 meaning highly similar and 0.0 meaning highly dissimilar
          type: number
    ImageDescriptionResponse:
      description: Result of recognizing an image
      type: object
      properties:
        Successful:
          description: Was the image processed successfully?
          type: boolean
        Highconfidence:
          description: Is the resulting best outcome recognition a high confidence outcome?
          type: boolean
        BestOutcome:
          $ref: '#/components/schemas/RecognitionOutcome'
          description: The best Machine Learning outcome
        RunnerUpOutcome:
          $ref: '#/components/schemas/RecognitionOutcome'
          description: Best backup ("runner up") Machine Learning outcome
    RecognitionOutcome:
      description: Specific recognition outcome
      type: object
      properties:
        ConfidenceScore:
          format: double
          description: Scores closer to 1 are better than scores closer to 0
          type: number
        Description:
          description: English language description of the image
          type: string
    TextItem:
      description: Individual instance of text occuring in an image; one piece of text
      type: object
      properties:
        DetectedText:
          description: Text detected in the image
          type: string
        LeftX:
          format: int32
          description: Left X coordinate of the text location; 0 represents the left edge of the input image
          type: integer
        TopY:
          format: int32
          description: Top Y coordinate of the text location; 0 represents the top edge of the input image
          type: integer
        Width:
          format: int32
          description: Width in pixels of the text item
          type: integer
        Height:
          format: int32
          description: Height in pixels of the text item
          type: integer
    WordTimestamp:
      description: A single word with its DTW-aligned time range and position in the output text.
      type: object
      properties:
        Word:
          description: The word text
          type: string
          example: ' Hello'
        CharacterOffsetStart:
          format: int32
          description: Start character offset (0-based) in TextResult
          type: integer
          example: 0
        CharacterOffsetEnd:
          format: int32
          description: End character offset (exclusive) in TextResult
          type: integer
          example: 6
        StartTimeMs:
          format: int64
          description: Start time of this word in the audio, in milliseconds
          type: integer
          example: 0
        EndTimeMs:
          format: int64
          description: End time of this word in the audio, in milliseconds
          type: integer
          example: 500
      additionalProperties: false
    SpeechRecognitionResult:
      description: Result of recognizing speech
      type: object
      properties:
        TextResult:
          description: Recognition result in text format
          type: string
          example: Hello world, this is a test.
        Timestamps:
          description: Token-level timestamps with character offsets into TextResult
          type: array
          items:
            $ref: '#/components/schemas/TokenTimestamp'
      additionalProperties: false
    TokenTimestamp:
      description: A single token with its time range and position in the output text
      type: object
      properties:
        Token:
          description: The token text (word or subword)
          type: string
          example: ' Hello'
        CharacterOffsetStart:
          format: int32
          description: Start character offset (0-based) in TextResult
          type: integer
          example: 0
        CharacterOffsetEnd:
          format: int32
          description: End character offset (exclusive) in TextResult
          type: integer
          example: 6
        StartTimeMs:
          format: int64
          description: Start time of this token in the audio, in milliseconds
          type: integer
          example: 0
        EndTimeMs:
          format: int64
          description: End time of this token in the audio, in milliseconds
          type: integer
          example: 500
      additionalProperties: false
    SpeechRecognitionResultAdvanced:
      description: 'Result of recognizing speech with the higher-accuracy file/advanced endpoint.

        Word-oriented (one entry per word, not per BPE sub-token) and produced

        from DTW-aligned timestamps.'
      type: object
      properties:
        TextResult:
          description: Recognition result in text format
          type: string
          example: Hello world, this is a test.
        Words:
          description: 'Word-level timestamps with character offsets into TextResult.

            Timestamps are derived via Dynamic Time Warping (DTW) alignment for

            substantially better accuracy than the default token-timestamp path.'
          type: array
          items:
            $ref: '#/components/schemas/WordTimestamp'
      additionalProperties: false
  securitySchemes:
    Apikey:
      type: apiKey
      description: API Key Authentication
      name: Apikey
      in: header
x-refined-from:
- cloudmersive-image-openapi.json
- cloudmersive-speech-openapi.json