Alibaba AI Docs

Appearance

Synchronous API details ​

The general-purpose text embedding model converts text data into numerical vectors for downstream tasks like semantic search, recommendation, clustering, and classification.

Model overview ​

Singapore ​

ModelEmbedding dimensionsMax rows**Max tokens per line **(Note)Price (per 1M input tokens)Supported languages**Free quota **(Note)
text-embedding-v4 ** Part of the Qwen3-Embedding series2,048, 1,536, 1,024 (default), 768, 512, 256, 128, 64108,192$0.07Chinese, English, Spanish, French, Portuguese, Indonesian, Japanese, Korean, German, Russian, and over 100 other major languages1 million tokens Validity: 90 days after you activate Model Studio
text-embedding-v31,024 (default), 768, 512Chinese, English, Spanish, French, Portuguese, Indonesian, Japanese, Korean, German, Russian, and over 50 other major languages500,000 tokens Validity: 90 days after you activate Model Studio

China (Beijing) ​

Model**Embedding dimensionsMax rowsMax tokens per linePrice (per 1M input tokens)Supported languages
text-embedding-v4 ** Part of the Qwen3-Embedding series2,048, 1,536, 1,024 (default), 768, 512, 256, 128, 64108,192$0.072Chinese, English, Spanish, French, Portuguese, Indonesian, Japanese, Korean, German, Russian, and over 100 other major languages, plus multiple programming languages

China (Hong Kong) ​

Model**Embedding dimensionsMax rowsMax tokens per linePrice (per 1M input tokens)Supported languages
text-embedding-v4 ** Part of the Qwen3-Embedding series2,048, 1,536, 1,024 (default), 768, 512, 256, 128, 64108,192$0.07Chinese, English, Spanish, French, Portuguese, Indonesian, Japanese, Korean, German, Russian, and over 100 other major languages, plus multiple programming languages

For model rate limits, see Rate limiting.

Prerequisites ​

Users familiar with the OpenAI ecosystem can use the OpenAI-compatible API for a quick migration. The DashScope API provides more unique features.

Create an API key and export the API key as an environment variable. If you use an SDK to make calls, install the DashScope SDK.

OpenAI compatibility ​

The base_url****to configure for SDK calls:

The endpoint****to configure for HTTP calls:

  • Singapore: POSThttps://dashscope-intl.aliyuncs.com/compatible-mode/v1/embeddings

  • China (Beijing): POSThttps://dashscope.aliyuncs.com/compatible-mode/v1/embeddings

  • China (Hong Kong): POSThttps://cn-hongkong.dashscope.aliyuncs.com/compatible-mode/v1/embeddings

Request body ​

## Input string ​

## Python ​

python
import os
from openai import OpenAI

client = OpenAI(
 # If you use a model in the China (Beijing) region, you must use an API key from that region. Get one at: https://bailian.console.alibabacloud.com/?tab=model#/api-key
 api_key=os.getenv("DASHSCOPE_API_KEY"), # If the environment variable is not set, replace the placeholder with your API key.
 # If you use a model in the China (Beijing) region, replace the URL with: https://dashscope.aliyuncs.com/compatible-mode/v1
 base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
)

completion = client.embeddings.create(
 model="text-embedding-v4",
 input='The clothes are of good quality and look good, definitely worth the wait. I love them.',
 dimensions=1024,
 encoding_format="float"
)

print(completion.model_dump_json())

## Java ​

java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.HashMap;
import java.util.Map;
import com.alibaba.dashscope.utils.JsonUtils;

public final class Main {
 public static void main(String\[\] args) {
 // If you use a model in the China (Beijing) region, you must use an API key from that region. Get one at: https://bailian.console.alibabacloud.com/?tab=model#/api-key
 String apiKey = System.getenv("DASHSCOPE_API_KEY");
 if (apiKey == null) {
 System.out.println("DASHSCOPE_API_KEY not found in environment variables");
 return;
 }
 // If you use a model in the China (Beijing) region, replace the URL with: https://dashscope.aliyuncs.com/compatible-mode/v1/embeddings
 String baseUrl = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1/embeddings";
 HttpClient client = HttpClient.newHttpClient();

Map<String, Object> requestBody = new HashMap\<\>();
 requestBody.put("model", "text-embedding-v4");
 requestBody.put("input", "The wind is strong, the sky is high, and the apes cry mournfully. The islet is clear, the sand is white, and the birds fly back. The boundless forest sheds its leaves shower by shower. The endless river rolls on wave after wave.");
 requestBody.put("dimensions", 1024);
 requestBody.put("encoding_format", "float");

try {
 String requestBodyString = JsonUtils.toJson(requestBody);
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(baseUrl))
 .header("Content-Type", "application/json")
 .header("Authorization", "Bearer " + apiKey)
 .POST(HttpRequest.BodyPublishers.ofString(requestBodyString))
 .build();

HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
 if (response.statusCode() == 200) {
 System.out.println("Response: " + response.body());
 } else {
 System.out.printf("Failed to retrieve response, status code: %d, response: %s%n", response.statusCode(), response.body());
 }
 } catch (Exception e) {
 System.err.println("Error: " + e.getMessage());
 }
 }
}

## curl ​

If you use a model in the China (Beijing) region, you must use an API key from that region and replace the URL with https://dashscope.aliyuncs.com/compatible-mode/v1/embeddings.

curl
curl --location 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1/embeddings' \\
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \\
--header 'Content-Type: application/json' \\
--data '{
 "model": "text-embedding-v4",
 "input": "The wind is strong, the sky is high, and the apes cry mournfully. The islet is clear, the sand is white, and the birds fly back. The boundless forest sheds its leaves shower by shower. The endless river rolls on wave after wave.",
 "dimensions": 1024,
 "encoding_format": "float"
}'

## Input string list ​

## Python ​

python
import os
from openai import OpenAI

client = OpenAI(
 # If you use a model in the China (Beijing) region, you must use an API key from that region. Get one at: https://bailian.console.alibabacloud.com/?tab=model#/api-key
 api_key=os.getenv("DASHSCOPE_API_KEY"), # If the environment variable is not set, replace the placeholder with your API key.
 # If you use a model in the China (Beijing) region, replace the URL with: https://dashscope.aliyuncs.com/compatible-mode/v1
 base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
)

completion = client.embeddings.create(
 model="text-embedding-v4",
 input=\['The wind is strong, the sky is high, and the apes cry mournfully.', 'The islet is clear, the sand is white, and the birds fly back.', 'The boundless forest sheds its leaves shower by shower.', 'The endless river rolls on wave after wave.'\],
 dimensions=1024,
 encoding_format="float"
)

print(completion.model_dump_json())

## Java ​

java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.Arrays;
import com.alibaba.dashscope.utils.JsonUtils;

public final class Main {
 public static void main(String\[\] args) {
 // Get the API key from an environment variable. If not configured, replace it with your API key.
 // If you use a model in the China (Beijing) region, you must use an API key from that region. Get one at: https://bailian.console.alibabacloud.com/?tab=model#/api-key
 String apiKey = System.getenv("DASHSCOPE_API_KEY");
 if (apiKey == null) {
 System.out.println("DASHSCOPE_API_KEY not found in environment variables");
 return;
 }
 // If you use a model in the China (Beijing) region, replace the URL with: https://dashscope.aliyuncs.com/compatible-mode/v1/embeddings
 String baseUrl = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1/embeddings";
 HttpClient client = HttpClient.newHttpClient();
 Map<String, Object> requestBody = new HashMap\<\>();
 requestBody.put("model", "text-embedding-v4");
 List inputList = Arrays.asList("The wind is strong, the sky is high, and the apes cry mournfully.", "The islet is clear, the sand is white, and the birds fly back.", "The boundless forest sheds its leaves shower by shower.", "The endless river rolls on wave after wave.");
 requestBody.put("input", inputList);
 requestBody.put("encoding_format", "float");

try {
 // Convert the request body to a JSON string.
 String requestBodyString = JsonUtils.toJson(requestBody);

// Build the HTTP request.
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(baseUrl))
 .header("Content-Type", "application/json")
 .header("Authorization", "Bearer " + apiKey)
 .POST(HttpRequest.BodyPublishers.ofString(requestBodyString))
 .build();

// Send the request and receive the response.
 HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
 if (response.statusCode() == 200) {
 System.out.println("Response: " + response.body());
 } else {
 System.out.printf("Failed to retrieve response, status code: %d, response: %s%n", response.statusCode(), response.body());
 }
 } catch (Exception e) {
 // Catch and print the exception.
 System.err.println("Error: " + e.getMessage());
 }
 }
}

## curl ​

If you use a model in the China (Beijing) region, you must use an API key from that region and replace the URL with https://dashscope.aliyuncs.com/compatible-mode/v1/embeddings.

curl
curl --location 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1/embeddings' \\
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \\
--header 'Content-Type: application/json' \\
--data '{
 "model": "text-embedding-v4",
 "input": \[
 "The wind is strong, the sky is high, and the apes cry mournfully.",
 "The islet is clear, the sand is white, and the birds fly back.",
 "The boundless forest sheds its leaves shower by shower.",
 "The endless river rolls on wave after wave."
 \],
 "dimensions": 1024,
 "encoding_format": "float"
}'

## Input file ​

## Python ​

python
import os
from openai import OpenAI

client = OpenAI(
 # If you use a model in the China (Beijing) region, you must use an API key from that region. Get one at: https://bailian.console.alibabacloud.com/?tab=model#/api-key
 api_key=os.getenv("DASHSCOPE_API_KEY"), # If the environment variable is not set, replace the placeholder with your API key.
 # If you use a model in the China (Beijing) region, replace the URL with: https://dashscope.aliyuncs.com/compatible-mode/v1
 base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
)

with open('texts_to_embedding.txt', 'r', encoding='utf-8') as f:
 completion = client.embeddings.create(
 model="text-embedding-v4",
 input=f,
 encoding_format="float"
 )
print(completion.model_dump_json())

## Java ​

java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.HashMap;
import java.util.Map;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import com.alibaba.dashscope.utils.JsonUtils;

public class Main {
 public static void main(String\[\] args) {
 // Get the API key from an environment variable. If not configured, replace it with your API key.
 // If you use a model in the China (Beijing) region, you must use an API key from that region. Get one at: https://bailian.console.alibabacloud.com/?tab=model#/api-key
 String apiKey = System.getenv("DASHSCOPE_API_KEY");
 if (apiKey == null) {
 System.out.println("DASHSCOPE_API_KEY not found in environment variables");
 return;
 }
 // If you use a model in the China (Beijing) region, replace the URL with: https://dashscope.aliyuncs.com/compatible-mode/v1/embeddings
 String baseUrl = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1/embeddings";
 HttpClient client = HttpClient.newHttpClient();

// Read the input file.
 StringBuilder inputText = new StringBuilder();
 try (BufferedReader reader = new BufferedReader(new FileReader("\"))) {
 String line;
 while ((line = reader.readLine()) != null) {
 inputText.append(line).append("\\n");
 }
 } catch (IOException e) {
 System.err.println("Error reading input file: " + e.getMessage());
 return;
 }

Map<String, Object> requestBody = new HashMap\<\>();
 requestBody.put("model", "text-embedding-v4");
 requestBody.put("input", inputText.toString().trim());
 requestBody.put("dimensions", 1024);
 requestBody.put("encoding_format", "float");

try {
 String requestBodyString = JsonUtils.toJson(requestBody);

// Build the HTTP request.
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(baseUrl))
 .header("Content-Type", "application/json")
 .header("Authorization", "Bearer " + apiKey)
 .POST(HttpRequest.BodyPublishers.ofString(requestBodyString))
 .build();
 HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
 if (response.statusCode() == 200) {
 System.out.println("Response: " + response.body());
 } else {
 System.out.printf("Failed to retrieve response, status code: %d, response: %s%n", response.statusCode(), response.body());
 }
 } catch (Exception e) {
 System.err.println("Error: " + e.getMessage());
 }
 }
}

## curl ​

If you use a model in the China (Beijing) region, you must use an API key from that region and replace the URL with https://dashscope.aliyuncs.com/compatible-mode/v1/embeddings. Replace 'texts_to_embedding.txt' with your file name or path.

curl
FILE_CONTENT=$(cat texts_to_embedding.txt \| jq -Rs .)
curl --location 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1/embeddings' \\
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \\
--header 'Content-Type: application/json' \\
--data '{
 "model": "text-embedding-v4",
 "input": \['"$FILE_CONTENT"'\],
 "dimensions": 1024,
 "encoding_format": "float"
}'

<b>model *string* required** The name of the model to call. See the Model overview table for model names.

**input **array or string or file* *required The input text to process. The input can be a string, an array of strings, or a file. If the input is a string, the maximum length is 8,192 tokens. If the input is a list of strings or a file, the maximum batch size is 10 items (lines), and each item (line) can contain up to 8,192 tokens. dimensions *integer* optional The dimension of the output embedding vectors. Must be one of the following values: 2048 (for text-embedding-v4 only), 1536 (for text-embedding-v4 only), 1024, 768, 512, 256, 128, or 64. The default value is 1024. encoding_format *string* optional The returned embedding format. Currently, only float is supported.

Response object ​

## Successful response ​

json
{
 "data": \[
 {
 "embedding": \[
 -0.0695386752486229, 0.030681096017360687, ...
 \],
 "index": 0,
 "object": "embedding"
 },
 ...
 {
 "embedding": \[
 -0.06348952651023865, 0.060446035116910934, ...
 \],
 "index": 5,
 "object": "embedding"
 }
 \],
 "model": "text-embedding-v4",
 "object": "list",
 "usage": {
 "prompt_tokens": 184,
 "total_tokens": 184
 },
 "id": "73591b79-d194-9bca-8bb5-xxxxxxxxxxxx"
}

## Error response ​

json
{
 "error": {
 "message": "Incorrect API key provided. ",
 "type": "invalid_request_error",
 "param": null,
 "code": "invalid_api_key"
 }
}
     **data **`*array*` A list of the resulting embedding objects.

Property **embedding ***list* The embedding vector, returned as an array of floating-point numbers. **index ***integer* The index of the corresponding input text in the input array. **object **string The object type. The value is always embedding.

 **model **`*string*` The name of the model used for this call.     **object ***string* The object type. The value is always `list`.

**usage ***object*Property **prompt_tokens **integer The number of tokens in the input text. total_tokens integer The total number of tokens in the input. This count is determined by how the model's tokenizer parses the input string.

**id ***string * A unique request identifier, used for tracing and troubleshooting.

DashScope ​

base_url****for SDK calls:

Endpoint for HTTP calls:

Request body ​

## Input string ​

## Python ​

python
import dashscope
from http import HTTPStatus

# If you use a model in the China (Beijing) region, replace the URL with: https://dashscope.aliyuncs.com/api/v1
dashscope.base_http_api_url = 'https://dashscope-intl.aliyuncs.com/api/v1'

resp = dashscope.TextEmbedding.call(
 model=dashscope.TextEmbedding.Models.text_embedding_v4,
 input='A swift wind, a high sky, and the gibbons cry mournfully. A clear islet, white sand, and the birds fly back. Boundless rustling woods shed their leaves. The endless Yangtze River comes rolling in.',
 dimension=1024,
 output_type="dense\&sparse"
)

print(resp) if resp.status_code == HTTPStatus.OK else print(resp)

## Java ​

java
import java.util.Arrays;
import java.util.concurrent.Semaphore;
import com.alibaba.dashscope.common.ResultCallback;
import com.alibaba.dashscope.embeddings.TextEmbedding;
import com.alibaba.dashscope.embeddings.TextEmbeddingParam;
import com.alibaba.dashscope.embeddings.TextEmbeddingResult;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.utils.Constants;

public final class Main {
 static {
 // If you use a model in the China (Beijing) region, replace the URL with: https://dashscope.aliyuncs.com/api/v1
 Constants.baseHttpApiUrl="https://dashscope-intl.aliyuncs.com/api/v1";
 }
 public static void basicCall() throws ApiException, NoApiKeyException{
 TextEmbeddingParam param = TextEmbeddingParam
 .builder()
 .model(TextEmbedding.Models.TEXT_EMBEDDING_V4)
 .texts(Arrays.asList("A swift wind, a high sky, and the gibbons cry mournfully.", "A clear islet, white sand, and the birds fly back.", "Boundless rustling woods shed their leaves.", "The endless Yangtze River comes rolling in.")).build();
 TextEmbedding textEmbedding = new TextEmbedding();
 TextEmbeddingResult result = textEmbedding.call(param);
 System.out.println(result);
 }

public static void callWithCallback() throws ApiException, NoApiKeyException, InterruptedException{
 TextEmbeddingParam param = TextEmbeddingParam
 .builder()
 .model(TextEmbedding.Models.TEXT_EMBEDDING_V3)
 .texts(Arrays.asList("A swift wind, a high sky, and the gibbons cry mournfully.", "A clear islet, white sand, and the birds fly back.", "Boundless rustling woods shed their leaves.", "The endless Yangtze River comes rolling in.")).build();
 TextEmbedding textEmbedding = new TextEmbedding();
 Semaphore sem = new Semaphore(0);
 textEmbedding.call(param, new ResultCallback() {

@Override
 public void onEvent(TextEmbeddingResult message) {
 System.out.println(message);
 }
 @Override
 public void onComplete(){
 sem.release();
 }

@Override
 public void onError(Exception err){
 System.out.println(err.getMessage());
 err.printStackTrace();
 sem.release();
 }

});
 sem.acquire();
 }

public static void main(String\[\] args){
 try{
 callWithCallback();
 }catch(ApiException\|NoApiKeyException\|InterruptedException e){
 e.printStackTrace();
 System.out.println(e);

}
 try {
 basicCall();
 } catch (ApiException \| NoApiKeyException e) {
 System.out.println(e.getMessage());
 }
 System.exit(0);
 }
}

## curl ​

** If you use a model in the China (Beijing) region, use an API key for that region and replace the URL with: https://dashscope.aliyuncs.com/api/v1/services/embeddings/text-embedding/text-embedding

curl
curl --location 'https://dashscope-intl.aliyuncs.com/api/v1/services/embeddings/text-embedding/text-embedding' \\
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \\
--header 'Content-Type: application/json' \\
--data '{
 "model": "text-embedding-v4",
 "input": {
 "texts": \[
 "A swift wind, a high sky, and the gibbons cry mournfully. A clear islet, white sand, and the birds fly back. Boundless rustling woods shed their leaves. The endless Yangtze River comes rolling in."
 \]
 },
 "parameters": {
 "dimension": 1024,
 "output_type": "dense"
 }
}'

## Input string list ​

## Python ​

python
import dashscope
from http import HTTPStatus

# If you use a model in the China (Beijing) region, replace the URL with: https://dashscope.aliyuncs.com/api/v1
dashscope.base_http_api_url = 'https://dashscope-intl.aliyuncs.com/api/v1'
DASHSCOPE_MAX_BATCH_SIZE = 10

inputs = \['A swift wind, a high sky, and the gibbons cry mournfully.', 'A clear islet, white sand, and the birds fly back.', 'Boundless rustling woods shed their leaves.', 'The endless Yangtze River comes rolling in.'\]

result = None
batch_counter = 0
for i in range(0, len(inputs), DASHSCOPE_MAX_BATCH_SIZE):
 batch = inputs\[i:i + DASHSCOPE_MAX_BATCH_SIZE\]
 resp = dashscope.TextEmbedding.call(
 model=dashscope.TextEmbedding.Models.text_embedding_v4,
 input=batch,
 dimension=1024
 )
 if resp.status_code == HTTPStatus.OK:
 if result is None:
 result = resp
 else:
 for emb in resp.output\['embeddings'\]:
 emb\['text_index'\] += batch_counter
 result.output\['embeddings'\].append(emb)
 result.usage\['total_tokens'\] += resp.usage\['total_tokens'\]
 else:
 print(resp)
 batch_counter += len(batch)

print(result)

## Java ​

java
import java.util.Arrays;
import java.util.List;
import com.alibaba.dashscope.embeddings.TextEmbedding;
import com.alibaba.dashscope.embeddings.TextEmbeddingParam;
import com.alibaba.dashscope.embeddings.TextEmbeddingResult;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.utils.Constants;

public final class Main {
 static {
 // If you use a model in the China (Beijing) region, replace the URL with: https://dashscope.aliyuncs.com/api/v1
 Constants.baseHttpApiUrl="https://dashscope-intl.aliyuncs.com/api/v1";
 }
 private static final int DASHSCOPE_MAX_BATCH_SIZE = 10;

public static void main(String\[\] args) {
 List inputs = Arrays.asList(
 "A swift wind, a high sky, and the gibbons cry mournfully.",
 "A clear islet, white sand, and the birds fly back.",
 "Boundless rustling woods shed their leaves.",
 "The endless Yangtze River comes rolling in."
 );

TextEmbeddingResult result = null;
 int batchCounter = 0;

for (int i = 0; i \< inputs.size(); i += DASHSCOPE_MAX_BATCH_SIZE) {
 List batch = inputs.subList(i, Math.min(i + DASHSCOPE_MAX_BATCH_SIZE, inputs.size()));
 TextEmbeddingParam param = TextEmbeddingParam.builder()
 .model(TextEmbedding.Models.TEXT_EMBEDDING_V4)
 .texts(batch)
 .build();

TextEmbedding textEmbedding = new TextEmbedding();
 try {
 TextEmbeddingResult resp = textEmbedding.call(param);
 if (resp != null) {
 if (result == null) {
 result = resp;
 } else {
 for (var emb : resp.getOutput().getEmbeddings()) {
 emb.setTextIndex(emb.getTextIndex() + batchCounter);
 result.getOutput().getEmbeddings().add(emb);
 }
 result.getUsage().setTotalTokens(result.getUsage().getTotalTokens() + resp.getUsage().getTotalTokens());
 }
 } else {
 System.out.println(resp);
 }
 } catch (ApiException \| NoApiKeyException e) {
 e.printStackTrace();
 }
 batchCounter += batch.size();
 }

System.out.println(result);
 }
}

## curl ​

If you use a model in the China (Beijing) region, use an API key for that region and replace the URL with: https://dashscope.aliyuncs.com/api/v1/services/embeddings/text-embedding/text-embedding

curl
curl --location 'https://dashscope-intl.aliyuncs.com/api/v1/services/embeddings/text-embedding/text-embedding' \\
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \\
--header 'Content-Type: application/json' \\
--data '{
 "model": "text-embedding-v4",
 "input": {
 "texts": \[
 "A swift wind, a high sky, and the gibbons cry mournfully.",
 "A clear islet, white sand, and the birds fly back.",
 "Boundless rustling woods shed their leaves.",
 "The endless Yangtze River comes rolling in."
 \]
 },
 "parameters": {
 "dimension": 1024,
 "output_type": "dense"
 }
}'

## Input file ​

## Python ​

python
import dashscope
from http import HTTPStatus
from dashscope import TextEmbedding

# If you use a model in the China (Beijing) region, replace the URL with: https://dashscope.aliyuncs.com/api/v1
dashscope.base_http_api_url = 'https://dashscope-intl.aliyuncs.com/api/v1'
# Make sure to replace 'texts_to_embedding.txt' with your own file name or path.
with open('texts_to_embedding.txt', 'r', encoding='utf-8') as f:
 resp = TextEmbedding.call(
 model=TextEmbedding.Models.text_embedding_v4,
 input=f,
 dimension=1024
 )

if resp.status_code == HTTPStatus.OK:
 print(resp)
 else:
 print(resp)

## Java ​

java
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import com.alibaba.dashscope.embeddings.TextEmbedding;
import com.alibaba.dashscope.embeddings.TextEmbeddingParam;
import com.alibaba.dashscope.embeddings.TextEmbeddingResult;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.utils.Constants;

public final class Main {
 static {
 // If you use a model in the China (Beijing) region, replace the URL with: https://dashscope.aliyuncs.com/api/v1
 Constants.baseHttpApiUrl="https://dashscope-intl.aliyuncs.com/api/v1";
 }
 public static void main(String\[\] args) {
 // Replace 'texts_to_embedding.txt' with the path to your file.
 try (BufferedReader reader = new BufferedReader(new FileReader("texts_to_embedding.txt"))) {
 StringBuilder content = new StringBuilder();
 String line;
 while ((line = reader.readLine()) != null) {
 content.append(line).append("\\n");
 }

TextEmbeddingParam param = TextEmbeddingParam.builder()
 .model(TextEmbedding.Models.TEXT_EMBEDDING_V4)
 .text(content.toString())
 .build();

TextEmbedding textEmbedding = new TextEmbedding();
 TextEmbeddingResult result = textEmbedding.call(param);

if (result != null) {
 System.out.println(result);
 } else {
 System.out.println("Failed to get embedding: " + result);
 }
 } catch (IOException \| ApiException \| NoApiKeyException e) {
 e.printStackTrace();
 }
 }
}

## curl ​

If you use a model in the China (Beijing) region, use an API key for that region and replace the URL with: https://dashscope.aliyuncs.com/api/v1/services/embeddings/text-embedding/text-embedding Replace 'texts_to_embedding.txt' with your file name or path.

curl
FILE_CONTENT=$(cat texts_to_embedding.txt \| jq -Rs .)
curl --location 'https://dashscope-intl.aliyuncs.com/api/v1/services/embeddings/text-embedding/text-embedding' \\
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \\
--header 'Content-Type: application/json' \\
--data '{
 "model": "text-embedding-v4",
 "input": {
 "texts": \['"$FILE_CONTENT"'\]
 },
 "parameters": {
 "dimension": 1024,
 "output_type": "dense"
 }
}'

<b>model **string* *required The model to use. For a list of available models, see the Model overview table.

**input **string* or *array* *required The text to process. The input can be a string, an array of strings, or a file. A single string can be up to 8,192 tokens. A list of strings or a file can contain up to 10 items (lines), with each item up to 8,192 tokens.

text_type *string** *optional ** When making an HTTP call, place <b>text_type **in the parameters object. Text converted to embeddings can be applied to downstream tasks such as retrieval, clustering, and classification. For asymmetric tasks such as retrieval, it is recommended to differentiate between query text (query) and document text (document) to achieve better retrieval performance. For symmetric tasks such as indexing, clustering, and classification, you can simply use the system default value of document.

dimension *integer* optional ** When making an HTTP call, place <b>dimension **in the parameters object. Specifies the embedding dimension for the output vector. Valid values are 2048 (for text-embedding-v4 only), 1536 (for text-embedding-v4 only), 1024, 768, 512, 256, 128, or 64. Defaults to 1024.

output_type *string* optional ** When making an HTTP call, place <b>output_type **in the parameters object. Specifies the output vector type. This parameter applies only to the text-embedding-v3 and text-embedding-v4 models. Valid values are dense, sparse, and dense\&sparse. Defaults to dense, which returns only the dense vector representation.

instruct *string* optional Provides custom instructions to guide the model in understanding the query intent. English instructions are recommended, as they typically improve performance by 1% to 5%.

Response object ​

## Successful response ​

json
{ "status_code": 200,
 "request_id": "1ba94ac8-e058-99bc-9cc1-7fdb37940a46",
 "code": "",
 "message": "",
 "output":{
 "embeddings": \[
 {
 "sparse_embedding":\[
 {"index":7149,"value":0.829,"token":"swift"},
 .....
 {"index":111290,"value":0.9004,"token":"mournfully"}\],
 "embedding": \[-0.006929283495992422,-0.005336422007530928, ...\],
 "text_index": 0
 },
 {
 "sparse_embedding":\[
 {"index":246351,"value":1.0483,"token":"islet"},
 .....
 {"index":2490,"value":0.8579,"token":"back"}\],
 "embedding": \[-0.006929283495992422,-0.005336422007530928, ...\],
 "text_index": 1
 },
 {
 "sparse_embedding":\[
 {"index":3759,"value":0.7065,"token":"Boundless"},
 .....
 {"index":1130,"value":0.815,"token":"leaves"}\],
 "embedding": \[-0.006929283495992422,-0.005336422007530928, ...\],
 "text_index": 2
 },
 {
 "sparse_embedding":\[
 {"index":562,"value":0.6752,"token":"endless"},
 .....
 {"index":1589,"value":0.7097,"token":"in"}\],
 "embedding": \[-0.001945948973298072,-0.005336422007530928, ...\],
 "text_index": 3
 }
 \]
 },
 "usage":{
 "total_tokens":27
 }
}

## Error response ​

json
{
 "code":"InvalidApiKey",
 "message":"Invalid API-key provided.",
 "request_id":"xxxxxxxx"
}
     **status_code** `string` The HTTP status code. A value of 200 indicates success.     **request_id** `string` A unique identifier for the request. Use this ID to trace and troubleshoot the request.     **code** `string` The error code returned if the request fails. This field is empty for successful requests.     **message** `string` A detailed error message if the request fails. This field is empty for successful requests.     **output **`*object*` The result of the task.

Properties **embeddings ***array* The model's output for the request. This is an array of objects, with each object corresponding to an input text. Propertiessparse_embedding *array* The sparse vector representation of the corresponding string. This applies only to text-embedding-v3 and text-embedding-v4. Propertiesindex *integer* The index of the token in the vocabulary. value *float* Indicates the weight or importance score of the Token. The higher the value, the greater the importance or relevance of the Token in the current text context. token *string* The text of the token.

embedding *array* The dense vector representation for the corresponding string. text_index *integer* The index of the corresponding text in the input array.

**usage ***object*Propertiestotal_tokens integer The number of tokens in the input, as calculated by the model's tokenizer.

Error codes ​

If a model call fails, see Error Messages.

Mirror of Alibaba Cloud Model Studio docs for reference and RAG. Not affiliated with Alibaba Cloud.

Source: alibabacloud.com/help/en/model-studio