---
type: api
title: Create an JinaAI inference endpoint
description: Create an inference endpoint to perform an inference task with the `jinaai` service.
url: https://www.elastic.co/elastic/docs-builder/docs/4371/api/doc/elasticsearch/operation/operation-inference-put-jinaai
resource: https://www.elastic.co/elastic/docs-builder/docs/4371/api/doc/elasticsearch/operation/operation-inference-put-jinaai
products:
  - Elasticsearch
---

# Create an JinaAI inference endpoint

Availability: 8.18+

## Paths

- `PUT` `/_inference/{task_type}/{jinaai_inference_id}`

- [Api key auth](/elastic/docs-builder/docs/4371/api/doc/elasticsearch/authentication#apikeyauth)
- [Basic auth](/elastic/docs-builder/docs/4371/api/doc/elasticsearch/authentication#basicauth)
- [Bearer auth](/elastic/docs-builder/docs/4371/api/doc/elasticsearch/authentication#bearerauth)

#### Path Parameters

- `task_type` (enum JinaAITaskType)
  The type of the inference task that the model will perform.
  Values: `embedding`, `rerank`, `text_embedding`
- `jinaai_inference_id` (string Id)
  The unique identifier of the inference endpoint.

## Description

Create an inference endpoint to perform an inference task with the `jinaai` service.

To review the available `rerank` models, refer to <https://jina.ai/reranker>.
To review the available `embedding` and `text_embedding` models, refer to <https://jina.ai/embeddings/>.

## Required authorization

* Cluster privileges: `manage_inference`

## Query String Parameters

- `timeout` (string Duration · default: 30s)
  Specifies the amount of time to wait for the inference endpoint to be created.

## Request Body

`application/json`

- `chunking_settings` ({} InferenceChunkingSettings) — optional
  The chunking configuration object.
Applies only to the `embedding` and text_embedding` task types.
Not applicable to the `rerank` task type.
  - `max_chunk_size` (number · default: 250) — optional
    The maximum size of a chunk in words.
This value cannot be lower than `20` (for `sentence` strategy) or `10` (for `word` strategy).
This value should not exceed the window size for the associated model.
  - `overlap` (number · default: 100) — optional
    The number of overlapping words for chunks.
It is applicable only to a `word` chunking strategy.
This value cannot be higher than half the `max_chunk_size` value.
  - `sentence_overlap` (number · default: 1) — optional
    The number of overlapping sentences for chunks.
It is applicable only for a `sentence` chunking strategy.
It can be either `1` or `0`.
  - `separator_group` (string) — optional
    Only applicable to the `recursive` strategy and required when using it.

Sets a predefined list of separators in the saved chunking settings based on the selected text type.
Values can be `markdown` or `plaintext`.

Using this parameter is an alternative to manually specifying a custom `separators` list.
  - `separators` ([] string) — optional
    Only applicable to the `recursive` strategy and required when using it.

A list of strings used as possible split points when chunking text.

Each string can be a plain string or a regular expression (regex) pattern.
The system tries each separator in order to split the text, starting from the first item in the list.

After splitting, it attempts to recombine smaller pieces into larger chunks that stay within
the `max_chunk_size` limit, to reduce the total number of chunks generated.
  - `strategy` (string · default: sentence) — optional
    The chunking strategy: `sentence`, `word`, `none` or `recursive`.

 * If `strategy` is set to `recursive`, you must also specify:

- `max_chunk_size`
- either `separators` or`separator_group`

Learn more about different chunking strategies in the linked documentation.
- `service` (enum JinaAIServiceType) — required
  The type of service supported for the specified task type. In this case, `jinaai`.
  Values: `jinaai`
- `service_settings` ({} JinaAIServiceSettings) — required
  Settings used to install the inference model. These settings are specific to the `jinaai` service.
  - `api_key` (string) — required
    A valid API key of your JinaAI account.

IMPORTANT: You need to provide the API key only once, during the inference model creation.
The get inference endpoint API does not retrieve your API key.
  - `model_id` (string) — required
    The name of the model to use for the inference task.
  - `rate_limit` ({} RateLimitSetting) — optional
    This setting helps to minimize the number of rate limit errors returned from JinaAI.
By default, the `jinaai` service sets the number of requests allowed per minute to 2000 for all task types.
    - `requests_per_minute` (number) — optional
      The number of requests allowed per minute.
By default, the number of requests allowed per minute is set by each service as follows:

* `alibabacloud-ai-search` service: `1000`
* `amazonbedrock` service: `240`
* `anthropic` service: `50`
* `azureaistudio` service: `240`
* `azureopenai` service and task type `text_embedding`: `1440`
* `azureopenai` service and task types `completion` or `chat_completion`: `120`
* `cohere` service: `10000`
* `contextualai` service: `1000`
* `elastic` service and task type `chat_completion`: `240`
* `fireworksai` service: `6000`
* `googleaistudio` service: `360`
* `googlevertexai` service: `30000`
* `hugging_face` service: `3000`
* `jinaai` service: `2000`
* `llama` service: `3000`
* `mistral` service: `240`
* `openai` service and task type `text_embedding`: `3000`
* `openai` service and task type `completion`: `500`
* `openshift_ai` service: `3000`
* `voyageai` service: `2000`
* `watsonxai` service: `120`
  - `similarity` (enum JinaAISimilarityType) — optional
    For an `embedding` or `text_embedding` task, the similarity measure. One of cosine, dot_product, l2_norm.
The default values varies with the embedding type.
For example, a float embedding type uses a `dot_product` similarity measure by default.
    Values: `cosine`, `dot_product`, `l2_norm`
  - `dimensions` (number) — optional
    For an `embedding` or `text_embedding` task, the number of dimensions the resulting output embeddings should have.
By default, the model's standard output dimension is used.
Refer to the Jina documentation for more information.
  - `embedding_type` (enum JinaAIElementType · default: float) — optional
    For an `embedding` or `text_embedding` task, the data type returned by the model.
Use `bit` for binary embeddings, which are encoded as bytes with signed int8 precision.
Use `binary` for binary embeddings, which are encoded as bytes with signed int8 precision (this is a synonym of `bit`).
Use `float` for the default float embeddings.
    Values: `binary`, `bit`, `float`
  - `multimodal_model` (boolean · default: true) — optional
    For the `embedding` task, whether the model supports multimodal inputs. If true, requests sent to the Jina model
will use the multimodal request format (a list of objects). If false, requests sent to the model will use the same
format as the `text_embedding` task (a list of strings). Setting this to `false` allows the `embedding` task to be
used with models that do not support multimodal requests.
- `task_settings` ({} JinaAITaskSettings) — optional
  Settings to configure the inference task.
These settings are specific to the task type you specified.
  - `return_documents` (boolean) — optional
    For a `rerank` task, return the doc text within the results.
  - `input_type` (enum JinaAITextEmbeddingTask) — optional
    For an `embedding` or `text_embedding` task, the task passed to the model.
Valid values are:

* `classification`: Use it for embeddings passed through a classifier.
* `clustering`: Use it for the embeddings run through a clustering algorithm.
* `ingest`: Use it for storing document embeddings in a vector database.
* `search`: Use it for storing embeddings of search queries run against a vector database to find relevant documents.
    Values: `classification`, `clustering`, `ingest`, `search`
  - `late_chunking` (boolean) — optional
    For an `embedding` or `text_embedding` task, controls when text is split into chunks.
When set to `true`, a request from Elasticsearch contains only chunks related to a single document. Instead of batching chunks across documents, Elasticsearch sends them in separate requests. This ensures that chunk embeddings retain context from the entire document, improving semantic quality.

If a document exceeds the model's context limits, or if the document contains non-text inputs (relevant when using the multimodal `embedding` task), late chunking is automatically disabled for that document only and standard chunking is used instead.

If not specified, defaults to `false`.
  - `top_n` (number) — optional
    For a `rerank` task, the number of most relevant documents to return.
It defaults to the number of the documents.
If this inference endpoint is used in a `text_similarity_reranker` retriever query and `top_n` is set, it must be greater than or equal to `rank_window_size` in the query.

## Response

`application/json`

- `chunking_settings` ({} InferenceChunkingSettings)
  The chunking configuration object.
Applies only to the `embedding`, `sparse_embedding` and `text_embedding` task types.
Not applicable to the `rerank`, `completion`, or `chat_completion` task types.
  - `max_chunk_size` (number · default: 250)
    The maximum size of a chunk in words.
This value cannot be lower than `20` (for `sentence` strategy) or `10` (for `word` strategy).
This value should not exceed the window size for the associated model.
  - `overlap` (number · default: 100)
    The number of overlapping words for chunks.
It is applicable only to a `word` chunking strategy.
This value cannot be higher than half the `max_chunk_size` value.
  - `sentence_overlap` (number · default: 1)
    The number of overlapping sentences for chunks.
It is applicable only for a `sentence` chunking strategy.
It can be either `1` or `0`.
  - `separator_group` (string)
    Only applicable to the `recursive` strategy and required when using it.

Sets a predefined list of separators in the saved chunking settings based on the selected text type.
Values can be `markdown` or `plaintext`.

Using this parameter is an alternative to manually specifying a custom `separators` list.
  - `separators` ([] string)
    Only applicable to the `recursive` strategy and required when using it.

A list of strings used as possible split points when chunking text.

Each string can be a plain string or a regular expression (regex) pattern.
The system tries each separator in order to split the text, starting from the first item in the list.

After splitting, it attempts to recombine smaller pieces into larger chunks that stay within
the `max_chunk_size` limit, to reduce the total number of chunks generated.
  - `strategy` (string · default: sentence)
    The chunking strategy: `sentence`, `word`, `none` or `recursive`.

 * If `strategy` is set to `recursive`, you must also specify:

- `max_chunk_size`
- either `separators` or`separator_group`

Learn more about different chunking strategies in the linked documentation.
- `service` (string)
  The service type
- `service_settings` (ServiceSettings)
  Settings specific to the service
- `task_settings` (TaskSettings)
  Task settings specific to the service and task type
- `inference_id` (string)
  The inference Id
- `task_type` (enum TaskTypeJinaAi)
  The task type
  Values: `embedding`, `text_embedding`, `rerank`
## Code Examples

#### Console

```console
PUT _inference/text_embedding/jinaai-embeddings
{
    "service": "jinaai",
    "service_settings": {
        "model_id": "jina-embeddings-v3",
        "api_key": "JinaAi-Api-key"
    }
}
```

#### JavaScript

```javascript
const response = await client.inference.put({
  task_type: "text_embedding",
  inference_id: "jinaai-embeddings",
  inference_config: {
    service: "jinaai",
    service_settings: {
      model_id: "jina-embeddings-v3",
      api_key: "JinaAi-Api-key",
    },
  },
});
```

#### Python

```python
resp = client.inference.put(
    task_type="text_embedding",
    inference_id="jinaai-embeddings",
    inference_config={
        "service": "jinaai",
        "service_settings": {
            "model_id": "jina-embeddings-v3",
            "api_key": "JinaAi-Api-key"
        }
    },
)
```

#### curl

```curl
curl -X PUT "$ELASTICSEARCH_URL/_inference/text_embedding/jinaai-embeddings" \
  -H "Authorization: ApiKey $ELASTIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "service": "jinaai",
    "service_settings": {
      "model_id": "jina-embeddings-v3",
      "api_key": "JinaAi-Api-key"
    }
  }'
```

#### Java

```java
client.inference().put(p -> p
    .inferenceId("jinaai-embeddings")
    .taskType(TaskType.TextEmbedding)
    .inferenceConfig(i -> i
        .service("jinaai")
        .serviceSettings(JsonData.fromJson("""
{"model_id":"jina-embeddings-v3","api_key":"JinaAi-Api-key"}
"""))
    )
);
```

#### C#

```c#
var response = await client.Inference
    .PutAsync(new PutInferenceRequest()
    {
        InferenceId = "jinaai-embeddings",
        TaskType = TaskType.TextEmbedding,
        InferenceConfig = new()
        {
            Service = "jinaai",
            ServiceSettings = JsonSerializer.Deserialize<JsonElement>("""
            {
              "model_id": "jina-embeddings-v3",
              "api_key": "JinaAi-Api-key"
            }
            """)
        }
    });
```

#### PHP

```php
$resp = $client->inference()->put([
    "task_type" => "text_embedding",
    "inference_id" => "jinaai-embeddings",
    "body" => [
        "service" => "jinaai",
        "service_settings" => [
            "model_id" => "jina-embeddings-v3",
            "api_key" => "JinaAi-Api-key",
        ],
    ],
]);
```

#### Ruby

```ruby
response = client.inference.put(
  task_type: "text_embedding",
  inference_id: "jinaai-embeddings",
  body: {
    "service": "jinaai",
    "service_settings": {
      "model_id": "jina-embeddings-v3",
      "api_key": "JinaAi-Api-key"
    }
  }
)
```

## Response Examples

#### A text embedding task

A successful response when creating a JinaAI `text_embedding` inference endpoint.

```json
{
   "inference_id": "jinaai-embeddings",
   "task_type": "text_embedding",
   "service": "jinaai",
   "service_settings": {
       "model_id": "jina-embeddings-v3",
       "rate_limit": {
           "requests_per_minute": 2000
       },
       "dimensions": 1024,
       "embedding_type": "float",
       "similarity": "dot_product"
   },
   "chunking_settings": {
       "strategy": "sentence",
       "max_chunk_size": 250,
       "sentence_overlap": 1
   }
}
```

#### A rerank task

A successful response when creating a JinaAI `rerank` inference endpoint.

```json
{
  "inference_id": "jinaai-rerank",
  "task_type": "rerank",
  "service": "jinaai",
  "service_settings": {
    "model_id": "jina-reranker-v2-base-multilingual",
    "rate_limit": {
      "requests_per_minute": 2000
    }
  },
  "task_settings": {
    "top_n": 10,
    "return_documents": true
  }
}
```

#### An embedding task using a multimodal model

A successful response when creating a JinaAI `embedding` inference endpoint.

```json
{
  "inference_id": "jinaai-embeddings-multimodal",
  "task_type": "embedding",
  "service": "jinaai",
  "service_settings": {
    "model_id": "jina-embeddings-v4",
    "rate_limit": {
      "requests_per_minute": 2000
    },
    "dimensions": 2048,
    "embedding_type": "float",
    "similarity": "dot_product",
    "multimodal_model": true
  },
  "chunking_settings": {
    "strategy": "sentence",
    "max_chunk_size": 250,
    "sentence_overlap": 1
  }
}
```

#### An embedding task using a non-multimodal model

A successful response when creating a JinaAI `embedding` inference endpoint with a model that does not support multimodal inputs.

```json
{
  "inference_id": "jinaai-embeddings-text-only",
  "task_type": "embedding",
  "service": "jinaai",
  "service_settings": {
    "model_id": "jina-embeddings-v3",
    "rate_limit": {
      "requests_per_minute": 2000
    },
    "dimensions": 1024,
    "embedding_type": "float",
    "similarity": "dot_product",
    "multimodal_model": false
  },
  "chunking_settings": {
    "strategy": "sentence",
    "max_chunk_size": 250,
    "sentence_overlap": 1
  }
}
```