Name: Multilingual E5 Large API: Text Embeddings in Many Languages
Brand: magicapi
SKU: api-magicapi-multilingual-text-embedding-api-beautyyuyanli-multilingual-e5-large
Availability: InStock
Author: API Market

Shashank Agarwal

# 🌐 Multilingual Text Embedding API (beautyyuyanli multilingual-e5-large)

## Overview
multilingual-e5-large is a text embedding model for many languages. It turns each text into a vector of numbers, so texts with similar meaning end up close together.

Send your texts in `texts` as a JSON list of strings (for example `["hello", "world"]`). The response holds one embedding per text, in the same order. In the example below each embedding has 1024 numbers. Embeddings are normalized by default (`normalize_embeddings`).

## Features
- **Many languages**: a multi-language model, so texts in different languages can be compared in the same vector space.
- **Several texts per request**: `texts` takes a JSON list of strings; you get one vector per text, in order.
- **Normalized vectors**: `normalize_embeddings` (default `true`) returns unit-length vectors, so a dot product equals cosine similarity.
- **Batch size**: `batch_size` (default 32) sets how many texts are processed together.

## Use Cases
1. **Semantic search**: embed documents and queries, then rank documents by similarity to the query.
2. **Cross-language retrieval**: match a query in one language with documents in another.
3. **Clustering and deduplication**: group texts with similar meaning or find near-duplicates.
4. **Retrieval for chatbots**: store embeddings in a vector database and fetch relevant passages for a language model.

## Visual Examples
### Example Input
Texts: `["In the water, fish are swimming.", "Fish swim in the water.", "A book lies open on the table."]`

Settings: `batch_size` 32, `normalize_embeddings` `true`.

### Example Output
Three embeddings of 1024 numbers each, one per text. The first numbers of each vector:

```json
[
  [-0.0020271323155611753, -0.016384996473789215, -0.02084992080926895, ...],
  [0.001451187883503735, -0.0232482198625803, -0.01903114840388298, ...],
  [0.03411397337913513, -0.019445784389972687, -0.026423556730151176, ...]
]
```

Because the vectors are normalized, the dot product of two vectors is their cosine similarity. For this run:

| Pair | Cosine similarity |
| --- | --- |
| "In the water, fish are swimming." and "Fish swim in the water." | 0.9764 |
| "In the water, fish are swimming." and "A book lies open on the table." | 0.7096 |
| "Fish swim in the water." and "A book lies open on the table." | 0.7192 |

The two sentences about fish score much closer to each other than to the sentence about the book.

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `texts` | string | No | the three example sentences shown above |  | Texts to embed, formatted as a JSON list of strings (for example `["hello", "world"]`) |
| `batch_size` | integer | No | `32` | minimum 0 | Batch size to use when processing text data |
| `normalize_embeddings` | boolean | No | `true` |  | Whether to normalize embeddings |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.0022 per API unit.
- **1 API unit = 1 request with up to 2 seconds of processing.** Longer requests use one unit per started 2-second block (for example, 3 seconds of processing = 2 units).
- **Example cost**: the request above processed in 0.03 seconds = 1 API unit = **$0.0022**.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/multilingual-text-embedding-api-beautyyuyanli-multilingual-e5-large`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 1 second and an overall timeout of 600 seconds (10 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/multilingual-text-embedding-api-beautyyuyanli-multilingual-e5-large/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "a06276a89f1a902d5fc225a9ca32b6e8e6292b7f3b136518878da97c458e2bad",
    "input": {
      "texts": "[\"In the water, fish are swimming.\", \"Fish swim in the water.\", \"A book lies open on the table.\"]",
      "batch_size": 32,
      "normalize_embeddings": true
    }
  }'
```

Response (201 Created):
```json
{
  "id": "qx7ahwxx3drmy0d1c6krqcfpwr",
  "version": "a06276a89f1a902d5fc225a9ca32b6e8e6292b7f3b136518878da97c458e2bad",
  "status": "starting",
  "created_at": "2026-10-22T03:29:05.505Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/multilingual-text-embedding-api-beautyyuyanli-multilingual-e5-large/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "qx7ahwxx3drmy0d1c6krqcfpwr",
  "status": "succeeded",
  "output": [
    [-0.0020271323155611753, -0.016384996473789215, -0.02084992080926895, ...],
    [0.001451187883503735, -0.0232482198625803, -0.01903114840388298, ...],
    [0.03411397337913513, -0.019445784389972687, -0.026423556730151176, ...]
  ],
  "error": null,
  "created_at": "2026-10-22T03:29:05.505Z",
  "started_at": "2026-10-22T03:29:05.540Z",
  "completed_at": "2026-10-22T03:29:05.567Z"
}
```

`output` is an array of embeddings, one per input text and in the same order. Each embedding is an array of numbers (1024 in this example). The response above is shortened to the first three numbers of each vector.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a `batch_size` below 0.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits
All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.
## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/multilingual-text-embedding-api-beautyyuyanli-multilingual-e5-large";

async function createAndWaitForPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "a06276a89f1a902d5fc225a9ca32b6e8e6292b7f3b136518878da97c458e2bad", input })
  });

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 600000;
  const pollInterval = 1000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(pollInterval);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

createAndWaitForPrediction({
    "texts": "[\"In the water, fish are swimming.\", \"Fish swim in the water.\", \"A book lies open on the table.\"]",
    "batch_size": 32,
    "normalize_embeddings": true
  }).then((output) => console.log(output));
```

#### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/multilingual-text-embedding-api-beautyyuyanli-multilingual-e5-large"

def create_and_wait_for_prediction(input_data):
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "a06276a89f1a902d5fc225a9ca32b6e8e6292b7f3b136518878da97c458e2bad", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])

def poll_for_results(prediction_id):
    max_timeout = 600
    poll_interval = 1
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < max_timeout:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]

        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 10 minutes")

print(create_and_wait_for_prediction({
    "texts": "[\"In the water, fish are swimming.\", \"Fish swim in the water.\", \"A book lies open on the table.\"]",
    "batch_size": 32,
    "normalize_embeddings": True
}))
```

## FAQ
- **How do I send several texts?**
  - Put them in `texts` as one JSON-encoded list of strings, for example `"[\"first text\", \"second text\"]"`. The field is a string, so the list itself is written as text.
- **How long is each embedding?**
  - In the example above each embedding has 1024 numbers.
- **How do I compare two texts?**
  - Compute the cosine similarity of their vectors. With `normalize_embeddings` set to `true` (the default) this is the dot product.
- **How much does a request cost?**
  - $0.0022 for each started 2 seconds of processing; the 3-text example above took 0.03 seconds and cost one unit.
- **Is the 201 response from POST an error?**
  - No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

## Contact Us
If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.


Multilingual E5 large API: turn texts in many languages into 1024 number embedding vectors for semantic search, clustering and similarity. Pay as you go.