GET

/v1/schemas/jina/embeddings/v1%2Fembeddings

kind inputactivity embeddingshash 46e66607…extracted Oct 10, 2026version currentsource upstream spec ↗

Request body

0 properties · 0 required · 0 $defs

This schema isn’t a plain object with properties — showing the raw JSON instead.

application/json
{
  "provider": "jina",
  "activity": "embeddings",
  "endpointId": "v1/embeddings",
  "kind": "input",
  "contentHash": "46e66607c38bb4eaabecd73340472a423d0ae6bcf7ba1c9c433ba718069d16dd",
  "specRevision": null,
  "provenance": {
    "sourceUrl": "https://api.jina.ai/openapi.json",
    "sourceHash": "e1c9fccc2a1a0167e472af73c52d57a7c2bed94f817c58b791d53d03facd058e",
    "fetchedAt": 1791609642,
    "extractorVersion": "1",
    "derivation": "upstream-spec",
    "verifiedAt": null
  },
  "createdAt": 1791609642,
  "supersededAt": null,
  "schema": {
    "oneOf": [
      {
        "$ref": "#/$defs/EmbeddingsV2Request"
      },
      {
        "$ref": "#/$defs/EmbeddingsV3Request"
      },
      {
        "$ref": "#/$defs/EmbeddingsV4Request"
      },
      {
        "$ref": "#/$defs/EmbeddingsV5Request"
      },
      {
        "$ref": "#/$defs/CodeEmbeddings500MRequest"
      },
      {
        "$ref": "#/$defs/CodeEmbeddings1500MRequest"
      },
      {
        "$ref": "#/$defs/ClipV1Request"
      },
      {
        "$ref": "#/$defs/ClipV2Request"
      },
      {
        "$ref": "#/$defs/ColbertV1Request"
      },
      {
        "$ref": "#/$defs/ColbertV2Request"
      }
    ],
    "title": "Embedding Request",
    "discriminator": {
      "propertyName": "model",
      "mapping": {
        "jina-embeddings-v2-base-en": "#/components/schemas/EmbeddingsV2Request",
        "jina-embeddings-v2-base-zh": "#/components/schemas/EmbeddingsV2Request",
        "jina-embeddings-v2-base-de": "#/components/schemas/EmbeddingsV2Request",
        "jina-embeddings-v2-base-es": "#/components/schemas/EmbeddingsV2Request",
        "jina-embeddings-v2-base-code": "#/components/schemas/EmbeddingsV2Request",
        "jina-embeddings-v3": "#/components/schemas/EmbeddingsV3Request",
        "jina-embeddings-v4": "#/components/schemas/EmbeddingsV4Request",
        "jina-embeddings-v5-text-nano": "#/components/schemas/EmbeddingsV5Request",
        "jina-embeddings-v5-text-small": "#/components/schemas/EmbeddingsV5Request",
        "jina-embeddings-v5-omni-small": "#/components/schemas/EmbeddingsV5Request",
        "jina-embeddings-v5-omni-nano": "#/components/schemas/EmbeddingsV5Request",
        "jina-code-embeddings-0.5b": "#/components/schemas/CodeEmbeddings500MRequest",
        "jina-code-embeddings-1.5b": "#/components/schemas/CodeEmbeddings1500MRequest",
        "jina-clip-v1": "#/components/schemas/ClipV1Request",
        "jina-clip-v2": "#/components/schemas/ClipV2Request",
        "jina-colbert-v1-en": "#/components/schemas/ColbertV1Request",
        "jina-colbert-v2": "#/components/schemas/ColbertV2Request"
      }
    },
    "$defs": {
      "AudioDoc": {
        "properties": {
          "audio": {
            "type": "string",
            "title": "Audio",
            "description": "Audio as a URL or base64-encoded string."
          }
        },
        "type": "object",
        "required": [
          "audio"
        ],
        "title": "AudioDoc"
      },
      "ClipV1Request": {
        "properties": {
          "embedding_type": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "float",
                  "base64",
                  "binary",
                  "ubinary"
                ]
              },
              {
                "items": {
                  "type": "string",
                  "enum": [
                    "float",
                    "base64",
                    "binary",
                    "ubinary"
                  ]
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Embedding Type",
            "description": "Output encoding format: `float`, `base64`, `binary`, `ubinary`, or a list of these."
          },
          "normalized": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Normalized",
            "description": "If true (default), embeddings are L2-normalized to unit length.",
            "default": true
          },
          "truncate": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Truncate",
            "description": "If true, truncates input exceeding the model's max token limit instead of returning an error.",
            "default": false
          },
          "model": {
            "type": "string",
            "const": "jina-clip-v1",
            "title": "Model",
            "description": "The CLIP model to use."
          },
          "input": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "$ref": "#/$defs/TextDoc"
              },
              {
                "$ref": "#/$defs/ImageDoc"
              },
              {
                "$ref": "#/$defs/PDFDoc"
              },
              {
                "items": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "$ref": "#/$defs/TextDoc"
                    },
                    {
                      "$ref": "#/$defs/ImageDoc"
                    }
                  ]
                },
                "type": "array"
              }
            ],
            "title": "Input",
            "description": "Content to embed: a string, `TextDoc`, `ImageDoc`, `PDFDoc`, or a list of items. PDFs must be sent individually. Images up to 8MB."
          }
        },
        "type": "object",
        "required": [
          "model",
          "input"
        ],
        "title": "ClipV1Request",
        "description": "CLIP v1 multimodal model for images and text in a shared vector space.",
        "example": {
          "embedding_type": "float",
          "input": [
            {
              "image": "https://i.ibb.co/nQNGqL0/beach1.jpg"
            },
            "A beautiful sunset over the beach"
          ],
          "model": "jina-clip-v1",
          "normalized": true
        }
      },
      "ClipV2Request": {
        "properties": {
          "embedding_type": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "float",
                  "base64",
                  "binary",
                  "ubinary"
                ]
              },
              {
                "items": {
                  "type": "string",
                  "enum": [
                    "float",
                    "base64",
                    "binary",
                    "ubinary"
                  ]
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Embedding Type",
            "description": "Output encoding format: `float`, `base64`, `binary`, `ubinary`, or a list of these."
          },
          "normalized": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Normalized",
            "description": "If true (default), embeddings are L2-normalized to unit length.",
            "default": true
          },
          "truncate": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Truncate",
            "description": "If true, truncates input exceeding the model's max token limit instead of returning an error.",
            "default": false
          },
          "model": {
            "type": "string",
            "const": "jina-clip-v2",
            "title": "Model",
            "description": "The CLIP model to use."
          },
          "input": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "$ref": "#/$defs/TextDoc"
              },
              {
                "$ref": "#/$defs/ImageDoc"
              },
              {
                "$ref": "#/$defs/PDFDoc"
              },
              {
                "items": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "$ref": "#/$defs/TextDoc"
                    },
                    {
                      "$ref": "#/$defs/ImageDoc"
                    }
                  ]
                },
                "type": "array"
              }
            ],
            "title": "Input",
            "description": "Content to embed: a string, `TextDoc`, `ImageDoc`, `PDFDoc`, or a list of items. PDFs must be sent individually. Images up to 8MB."
          },
          "task": {
            "anyOf": [
              {
                "type": "string",
                "const": "retrieval.query"
              },
              {
                "type": "null"
              }
            ],
            "title": "Task",
            "description": "Set to `retrieval.query` to optimize for search queries. Leave unset for documents."
          },
          "dimensions": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 1024,
                "exclusiveMinimum": 0
              },
              {
                "type": "null"
              }
            ],
            "title": "Dimensions",
            "description": "Number of dimensions for the output embedding. Range: 1-1024."
          }
        },
        "type": "object",
        "required": [
          "model",
          "input"
        ],
        "title": "ClipV2Request",
        "description": "CLIP v2 with Matryoshka representation learning for flexible dimensions.",
        "example": {
          "dimensions": 512,
          "embedding_type": "float",
          "input": [
            {
              "image": "https://i.ibb.co/nQNGqL0/beach1.jpg"
            },
            "Jina AI - Your Search Foundation - Supercharged"
          ],
          "model": "jina-clip-v2",
          "normalized": true,
          "task": "retrieval.query"
        }
      },
      "CodeEmbeddings1500MRequest": {
        "properties": {
          "embedding_type": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "float",
                  "base64",
                  "binary",
                  "ubinary"
                ]
              },
              {
                "items": {
                  "type": "string",
                  "enum": [
                    "float",
                    "base64",
                    "binary",
                    "ubinary"
                  ]
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Embedding Type",
            "description": "Output encoding format: `float`, `base64`, `binary`, `ubinary`, or a list of these."
          },
          "model": {
            "type": "string",
            "const": "jina-code-embeddings-1.5b",
            "title": "Model",
            "description": "The code embedding model to use."
          },
          "input": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "$ref": "#/$defs/TextDoc"
              },
              {
                "items": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "$ref": "#/$defs/TextDoc"
                    }
                  ]
                },
                "type": "array"
              }
            ],
            "title": "Input",
            "description": "Code or text to embed: a string, `TextDoc`, or a list of items."
          },
          "truncate": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Truncate",
            "description": "If true, truncates input exceeding the model's max token limit instead of returning an error.",
            "default": false
          },
          "dimensions": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 1536,
                "exclusiveMinimum": 0
              },
              {
                "type": "null"
              }
            ],
            "title": "Dimensions",
            "description": "Number of dimensions for the output embedding. Range: 1-1536."
          },
          "task": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "nl2code.query",
                  "nl2code.passage",
                  "qa.query",
                  "qa.passage",
                  "code2code.query",
                  "code2code.passage",
                  "code2nl.query",
                  "code2nl.passage",
                  "code2completion.query",
                  "code2completion.passage"
                ]
              },
              {
                "type": "null"
              }
            ],
            "title": "Task",
            "description": "Task type: `nl2code`, `qa`, `code2code`, `code2nl`, or `code2completion`. Use `.query` for queries, `.passage` for documents.",
            "default": "nl2code.query"
          }
        },
        "type": "object",
        "required": [
          "model",
          "input"
        ],
        "title": "CodeEmbeddings1500MRequest",
        "description": "Code embeddings (1.5b) for search over source, and between source and prose.",
        "examples": [
          {
            "dimensions": 512,
            "input": [
              "import * as ElementPlusIconsVue from '@element-plus/icons-vue'\nconst app = createApp(App)\nfor (const [key, component] of Object.entries(ElementPlusIconsVue)) {\n  app.component(key, component)\n}"
            ],
            "model": "jina-code-embeddings-1.5b",
            "task": "nl2code.passage"
          }
        ]
      },
      "CodeEmbeddings500MRequest": {
        "properties": {
          "embedding_type": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "float",
                  "base64",
                  "binary",
                  "ubinary"
                ]
              },
              {
                "items": {
                  "type": "string",
                  "enum": [
                    "float",
                    "base64",
                    "binary",
                    "ubinary"
                  ]
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Embedding Type",
            "description": "Output encoding format: `float`, `base64`, `binary`, `ubinary`, or a list of these."
          },
          "model": {
            "type": "string",
            "const": "jina-code-embeddings-0.5b",
            "title": "Model",
            "description": "The code embedding model to use."
          },
          "input": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "$ref": "#/$defs/TextDoc"
              },
              {
                "items": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "$ref": "#/$defs/TextDoc"
                    }
                  ]
                },
                "type": "array"
              }
            ],
            "title": "Input",
            "description": "Code or text to embed: a string, `TextDoc`, or a list of items."
          },
          "truncate": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Truncate",
            "description": "If true, truncates input exceeding the model's max token limit instead of returning an error.",
            "default": false
          },
          "dimensions": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 896,
                "exclusiveMinimum": 0
              },
              {
                "type": "null"
              }
            ],
            "title": "Dimensions",
            "description": "Number of dimensions for the output embedding. Range: 1-896."
          },
          "task": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "nl2code.query",
                  "nl2code.passage",
                  "qa.query",
                  "qa.passage",
                  "code2code.query",
                  "code2code.passage",
                  "code2nl.query",
                  "code2nl.passage",
                  "code2completion.query",
                  "code2completion.passage"
                ]
              },
              {
                "type": "null"
              }
            ],
            "title": "Task",
            "description": "Task type: `nl2code`, `qa`, `code2code`, `code2nl`, or `code2completion`. Use `.query` for queries, `.passage` for documents.",
            "default": "nl2code.query"
          }
        },
        "type": "object",
        "required": [
          "model",
          "input"
        ],
        "title": "CodeEmbeddings500MRequest",
        "description": "Code embeddings (0.5b) for search over source, and between source and prose.",
        "examples": [
          {
            "dimensions": 512,
            "embedding_type": "float",
            "input": [
              "import * as ElementPlusIconsVue from '@element-plus/icons-vue'\nconst app = createApp(App)\nfor (const [key, component] of Object.entries(ElementPlusIconsVue)) {\n  app.component(key, component)\n}"
            ],
            "model": "jina-code-embeddings-0.5b",
            "task": "nl2code.passage"
          }
        ]
      },
      "ColbertV1Request": {
        "properties": {
          "embedding_type": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "float",
                  "base64",
                  "binary",
                  "ubinary"
                ]
              },
              {
                "items": {
                  "type": "string",
                  "enum": [
                    "float",
                    "base64",
                    "binary",
                    "ubinary"
                  ]
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Embedding Type",
            "description": "Output encoding format: `float`, `base64`, `binary`, `ubinary`, or a list of these."
          },
          "model": {
            "type": "string",
            "const": "jina-colbert-v1-en",
            "title": "Model",
            "description": "The ColBERT model to use."
          },
          "input": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "$ref": "#/$defs/TextDoc"
              },
              {
                "items": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "$ref": "#/$defs/TextDoc"
                    }
                  ]
                },
                "type": "array"
              }
            ],
            "title": "Input",
            "description": "Text to embed: a string, `TextDoc`, or a list of items."
          },
          "input_type": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "query",
                  "document"
                ]
              },
              {
                "type": "null"
              }
            ],
            "title": "Input Type",
            "description": "Role of the input: `query` for search queries, `document` for passages.",
            "default": "document"
          }
        },
        "type": "object",
        "required": [
          "model",
          "input"
        ],
        "title": "ColbertV1Request",
        "description": "ColBERT v1 for token-level late interaction retrieval.",
        "example": {
          "embedding_type": "float",
          "input": [
            "A beautiful sunset over the beach",
            "Jina AI - Your Search Foundation - Supercharged"
          ],
          "input_type": "document",
          "model": "jina-colbert-v1-en"
        }
      },
      "ColbertV2Request": {
        "properties": {
          "embedding_type": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "float",
                  "base64",
                  "binary",
                  "ubinary"
                ]
              },
              {
                "items": {
                  "type": "string",
                  "enum": [
                    "float",
                    "base64",
                    "binary",
                    "ubinary"
                  ]
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Embedding Type",
            "description": "Output encoding format: `float`, `base64`, `binary`, `ubinary`, or a list of these."
          },
          "model": {
            "type": "string",
            "const": "jina-colbert-v2",
            "title": "Model",
            "description": "The ColBERT model to use."
          },
          "input": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "$ref": "#/$defs/TextDoc"
              },
              {
                "items": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "$ref": "#/$defs/TextDoc"
                    }
                  ]
                },
                "type": "array"
              }
            ],
            "title": "Input",
            "description": "Text to embed: a string, `TextDoc`, or a list of items."
          },
          "input_type": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "query",
                  "document"
                ]
              },
              {
                "type": "null"
              }
            ],
            "title": "Input Type",
            "description": "Role of the input: `query` for search queries, `document` for passages.",
            "default": "document"
          },
          "dimensions": {
            "anyOf": [
              {
                "type": "integer",
                "enum": [
                  64,
                  96,
                  128
                ]
              },
              {
                "type": "null"
              }
            ],
            "title": "Dimensions",
            "description": "Dimensions per token: `64`, `96`, or `128`. Defaults to 128."
          }
        },
        "type": "object",
        "required": [
          "model",
          "input"
        ],
        "title": "ColbertV2Request",
        "description": "ColBERT v2 with Matryoshka representation learning for flexible dimensions.",
        "example": {
          "dimensions": 128,
          "embedding_type": "float",
          "input": [
            "A beautiful sunset over the beach"
          ],
          "input_type": "query",
          "model": "jina-colbert-v2"
        }
      },
      "EmbeddingsV2Request": {
        "properties": {
          "embedding_type": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "float",
                  "base64",
                  "binary",
                  "ubinary"
                ]
              },
              {
                "items": {
                  "type": "string",
                  "enum": [
                    "float",
                    "base64",
                    "binary",
                    "ubinary"
                  ]
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Embedding Type",
            "description": "Output encoding format: `float`, `base64`, `binary`, `ubinary`, or a list of these."
          },
          "normalized": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Normalized",
            "description": "If true (default), embeddings are L2-normalized to unit length.",
            "default": true
          },
          "truncate": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Truncate",
            "description": "If true, truncates input exceeding the model's max token limit instead of returning an error.",
            "default": false
          },
          "model": {
            "type": "string",
            "enum": [
              "jina-embeddings-v2-base-en",
              "jina-embeddings-v2-base-zh",
              "jina-embeddings-v2-base-de",
              "jina-embeddings-v2-base-es",
              "jina-embeddings-v2-base-code"
            ],
            "title": "Model",
            "description": "The embedding model to use."
          },
          "input": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "$ref": "#/$defs/TextDoc"
              },
              {
                "items": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "$ref": "#/$defs/TextDoc"
                    }
                  ]
                },
                "type": "array"
              }
            ],
            "title": "Input",
            "description": "Text to embed: a string, `TextDoc`, or a list of items."
          }
        },
        "type": "object",
        "required": [
          "model",
          "input"
        ],
        "title": "EmbeddingsV2Request",
        "description": "Jina Embeddings v2 text embedding models.",
        "example": {
          "embedding_type": "float",
          "input": [
            "A beautiful sunset over the beach",
            "Jina AI - Your Search Foundation - Supercharged"
          ],
          "model": "jina-embeddings-v2-base-en",
          "normalized": true,
          "truncate": false
        }
      },
      "EmbeddingsV3Request": {
        "properties": {
          "embedding_type": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "float",
                  "base64",
                  "binary",
                  "ubinary"
                ]
              },
              {
                "items": {
                  "type": "string",
                  "enum": [
                    "float",
                    "base64",
                    "binary",
                    "ubinary"
                  ]
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Embedding Type",
            "description": "Output encoding format: `float`, `base64`, `binary`, `ubinary`, or a list of these."
          },
          "normalized": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Normalized",
            "description": "If true (default), embeddings are L2-normalized to unit length.",
            "default": true
          },
          "truncate": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Truncate",
            "description": "If true, truncates input exceeding the model's max token limit instead of returning an error.",
            "default": false
          },
          "model": {
            "type": "string",
            "const": "jina-embeddings-v3",
            "title": "Model",
            "description": "The embedding model to use."
          },
          "input": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "$ref": "#/$defs/TextDoc"
              },
              {
                "items": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "$ref": "#/$defs/TextDoc"
                    }
                  ]
                },
                "type": "array"
              }
            ],
            "title": "Input",
            "description": "Text to embed: a string, `TextDoc`, or a list of items."
          },
          "task": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "retrieval.query",
                  "retrieval.passage",
                  "text-matching",
                  "classification",
                  "separation"
                ]
              },
              {
                "type": "null"
              }
            ],
            "title": "Task",
            "description": "Task optimization: `retrieval.query` for queries, `retrieval.passage` for documents, `text-matching` for similarity, `classification`, or `separation` for clustering."
          },
          "late_chunking": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Late Chunking",
            "description": "If true, concatenates all inputs and processes as one sequence before splitting. Useful for context across chunks."
          },
          "dimensions": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 1024,
                "exclusiveMinimum": 0
              },
              {
                "type": "null"
              }
            ],
            "title": "Dimensions",
            "description": "Number of dimensions for the output embedding. Range: 1-1024."
          }
        },
        "type": "object",
        "required": [
          "model",
          "input"
        ],
        "title": "EmbeddingsV3Request",
        "description": "Jina Embeddings v3 with task-specific optimization and flexible dimensions.",
        "example": {
          "dimensions": 512,
          "embedding_type": "float",
          "input": [
            "A beautiful sunset over the beach"
          ],
          "late_chunking": false,
          "model": "jina-embeddings-v3",
          "normalized": true,
          "task": "retrieval.query"
        }
      },
      "EmbeddingsV4Request": {
        "properties": {
          "embedding_type": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "float",
                  "base64",
                  "binary",
                  "ubinary"
                ]
              },
              {
                "items": {
                  "type": "string",
                  "enum": [
                    "float",
                    "base64",
                    "binary",
                    "ubinary"
                  ]
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Embedding Type",
            "description": "Output encoding format: `float`, `base64`, `binary`, `ubinary`, or a list of these."
          },
          "model": {
            "type": "string",
            "const": "jina-embeddings-v4",
            "title": "Model",
            "description": "The embedding model to use."
          },
          "input": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "$ref": "#/$defs/TextDoc"
              },
              {
                "$ref": "#/$defs/ImageDoc"
              },
              {
                "$ref": "#/$defs/PDFDoc"
              },
              {
                "items": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "$ref": "#/$defs/TextDoc"
                    },
                    {
                      "$ref": "#/$defs/ImageDoc"
                    }
                  ]
                },
                "type": "array"
              }
            ],
            "title": "Input",
            "description": "Content to embed: a string, `TextDoc`, `ImageDoc`, `PDFDoc`, or a list of items. PDFs must be sent individually. Images up to 8MB; PDFs up to 8MB."
          },
          "truncate": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Truncate",
            "description": "If true, truncates input exceeding the model's max token limit instead of returning an error.",
            "default": false
          },
          "late_chunking": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Late Chunking",
            "description": "If true, concatenates all text inputs and processes as one sequence before splitting. Only works with text."
          },
          "dimensions": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 2048,
                "exclusiveMinimum": 0
              },
              {
                "type": "null"
              }
            ],
            "title": "Dimensions",
            "description": "Number of dimensions for the output embedding. Range: 1-2048."
          },
          "task": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "text-matching",
                  "retrieval.query",
                  "retrieval.passage",
                  "code.query",
                  "code.passage"
                ]
              },
              {
                "type": "null"
              }
            ],
            "title": "Task",
            "description": "Task optimization: `text-matching` (default), `retrieval.query`, `retrieval.passage`, `code.query`, or `code.passage`.",
            "default": "text-matching"
          },
          "return_multivector": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Return Multivector",
            "description": "If true, returns one embedding per token. Cannot be used with `dimensions`.",
            "default": false
          },
          "return_tokenized_input": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Return Tokenized Input",
            "description": "If true, returns tokens alongside multi-vector embeddings. Requires `return_multivector=true`.",
            "default": false
          }
        },
        "type": "object",
        "required": [
          "model",
          "input"
        ],
        "title": "EmbeddingsV4Request",
        "description": "Jina Embeddings v4 multimodal model for text, images, and PDFs.",
        "examples": [
          {
            "dimensions": 512,
            "embedding_type": "float",
            "input": [
              {
                "image": "https://i.ibb.co/nQNGqL0/beach1.jpg"
              },
              {
                "text": "A beautiful sunset over the beach"
              }
            ],
            "model": "jina-embeddings-v4"
          },
          {
            "embedding_type": "float",
            "input": [
              "Jina AI - Your Search Foundation - Supercharged"
            ],
            "late_chunking": true,
            "model": "jina-embeddings-v4",
            "task": "retrieval.passage"
          },
          {
            "dimensions": 512,
            "embedding_type": "float",
            "input": {
              "pdf": "https://example.com/sample.pdf"
            },
            "model": "jina-embeddings-v4"
          }
        ]
      },
      "EmbeddingsV5Request": {
        "properties": {
          "embedding_type": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "float",
                  "base64",
                  "binary",
                  "ubinary"
                ]
              },
              {
                "items": {
                  "type": "string",
                  "enum": [
                    "float",
                    "base64",
                    "binary",
                    "ubinary"
                  ]
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Embedding Type",
            "description": "Output encoding format: `float`, `base64`, `binary`, `ubinary`, or a list of these."
          },
          "normalized": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Normalized",
            "description": "If true (default), embeddings are L2-normalized to unit length.",
            "default": true
          },
          "truncate": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Truncate",
            "description": "If true, truncates input exceeding the model's max token limit instead of returning an error.",
            "default": false
          },
          "model": {
            "type": "string",
            "enum": [
              "jina-embeddings-v5-text-nano",
              "jina-embeddings-v5-text-small",
              "jina-embeddings-v5-omni-small",
              "jina-embeddings-v5-omni-nano"
            ],
            "title": "Model",
            "description": "The embedding model to use."
          },
          "input": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "$ref": "#/$defs/TextDoc"
              },
              {
                "$ref": "#/$defs/ImageDoc"
              },
              {
                "$ref": "#/$defs/VideoDoc"
              },
              {
                "$ref": "#/$defs/AudioDoc"
              },
              {
                "$ref": "#/$defs/PDFDoc"
              },
              {
                "items": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "$ref": "#/$defs/TextDoc"
                    },
                    {
                      "$ref": "#/$defs/ImageDoc"
                    },
                    {
                      "$ref": "#/$defs/VideoDoc"
                    },
                    {
                      "$ref": "#/$defs/AudioDoc"
                    },
                    {
                      "$ref": "#/$defs/MergedContentGroup"
                    }
                  ]
                },
                "type": "array"
              }
            ],
            "title": "Input",
            "description": "Content to embed: a string, `TextDoc`, `ImageDoc`, `VideoDoc`, `AudioDoc`, `PDFDoc`, or a list of these. A list item may also be a `{content: [...]}` group, fused into one embedding. A PDF must be sent on its own, not inside a list."
          },
          "task": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "retrieval.query",
                  "retrieval.passage",
                  "text-matching",
                  "clustering",
                  "classification"
                ]
              },
              {
                "type": "null"
              }
            ],
            "title": "Task",
            "description": "Task optimization: `retrieval.query` for queries, `retrieval.passage` for documents, `text-matching` for similarity, `clustering`, or `classification`.",
            "default": "text-matching"
          },
          "dimensions": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 1024,
                "exclusiveMinimum": 0
              },
              {
                "type": "null"
              }
            ],
            "title": "Dimensions",
            "description": "Number of dimensions for the output embedding. Range: 1-1024."
          }
        },
        "type": "object",
        "required": [
          "model",
          "input"
        ],
        "title": "EmbeddingsV5Request",
        "description": "Jina Embeddings v5, with task-specific adapters and truncatable\ndimensions. Text, images, video, audio and PDFs share one vector space, so\na query in any of them retrieves any other; the `omni` names are the ones\nto reach for when the corpus is not text.\n\nEach list item is one modality, except a `MergedContentGroup`\n(`{\"content\": [...]}`), which fuses several chunks into a single embedding\nin one forward pass.",
        "examples": [
          {
            "dimensions": 512,
            "embedding_type": "float",
            "input": [
              "A beautiful sunset over the beach"
            ],
            "model": "jina-embeddings-v5-text-small",
            "normalized": true,
            "task": "retrieval.query"
          },
          {
            "embedding_type": "float",
            "input": [
              {
                "image": "https://i.ibb.co/nQNGqL0/beach1.jpg"
              },
              {
                "text": "A beautiful sunset over the beach"
              }
            ],
            "model": "jina-embeddings-v5-omni-small",
            "task": "retrieval.passage"
          }
        ]
      },
      "ImageDoc": {
        "properties": {
          "image": {
            "type": "string",
            "title": "Image",
            "description": "Image as a URL or base64-encoded string."
          }
        },
        "type": "object",
        "required": [
          "image"
        ],
        "title": "ImageDoc"
      },
      "MergedContentGroup": {
        "properties": {
          "content": {
            "items": {
              "anyOf": [
                {
                  "$ref": "#/$defs/TextDoc"
                },
                {
                  "$ref": "#/$defs/ImageDoc"
                },
                {
                  "$ref": "#/$defs/VideoDoc"
                },
                {
                  "$ref": "#/$defs/AudioDoc"
                }
              ]
            },
            "type": "array",
            "minItems": 1,
            "title": "Content",
            "description": "Ordered list of modality chunks (text / image / video / audio). Must contain at least one chunk."
          }
        },
        "type": "object",
        "required": [
          "content"
        ],
        "title": "MergedContentGroup",
        "description": "Several chunks of different modalities fused into one embedding.\n\nThe group returns a single vector, and order within `content` is part of\nthe meaning — reordering it can change the result. A PDF cannot go inside\na group; send it as its own input."
      },
      "PDFDoc": {
        "properties": {
          "pdf": {
            "type": "string",
            "title": "Pdf",
            "description": "PDF as a URL or base64-encoded string."
          }
        },
        "type": "object",
        "required": [
          "pdf"
        ],
        "title": "PDFDoc"
      },
      "TextDoc": {
        "properties": {
          "text": {
            "type": "string",
            "title": "Text",
            "description": "Text content to process."
          }
        },
        "type": "object",
        "required": [
          "text"
        ],
        "title": "TextDoc"
      },
      "VideoDoc": {
        "properties": {
          "video": {
            "type": "string",
            "title": "Video",
            "description": "Video as a URL or base64-encoded string."
          }
        },
        "type": "object",
        "required": [
          "video"
        ],
        "title": "VideoDoc"
      }
    }
  }
}

Validate a payload

before you spend tokens
shell
$ curl -X POST https://modelschemas.com/v1/validate \
    -d '{"provider":"jina","endpointId":"v1/embeddings","payload":{…}}'
→ {"valid": false, "errors": [{"path": "#", "keyword": "required", …}]}