Get text embeddings
Turn text into numbers that capture its meaning, so 'cancel my plan' sits next to 'terminate subscription' even though they share no words. Use the result for search, duplicate checks or recommendations. Pay per use, no subscription.
Run it online
Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.
A sentence means nothing to a database until it's a list of numbers a distance function can compare.
What an embedding is
A database cannot compare sentences by meaning; it can only compare numbers. An embedding places a piece of text in a numeric space where nearby points mean similar things, whatever exact words were chosen. The idea goes back to research on word meaning in the 2000s, took off with word2vec in 2013, and later moved from single words to whole sentences and passages. Today the conversion takes one request: you send text and get coordinates back, with no model to host and no hardware to set up.
How teams use the vectors and what to watch for
A single embedding is rarely the goal in itself. It is usually the first step before a similarity search, a grouping pass or a classifier trained on the vectors. Assistants that answer from your documents embed each incoming question and compare it with stored passages to pick the right context. Support desks compare new tickets with recent ones to flag likely duplicates, and shops embed product descriptions once and reuse them for months. A common mistake is expecting the vector to search on its own: you still need to store the vectors and compare them.
Why raw text can't be searched by meaning
Keyword search matches characters, not intent, which is why a query for 'cancel my plan' misses a document that only says 'terminate subscription.' Embeddings fix that by placing text in a numeric space where nearby points mean similar things, regardless of the exact words chosen. search.embed is the step that gets a single piece of text into that space.
Where it fits in a real system
Teams building retrieval-augmented generation call this per query and per candidate chunk, comparing vectors to decide what context an LLM should see. Recommendation systems embed product descriptions once and reuse the vectors for months.
What you can do with it
Query-time retrieval for RAG
An application embeds each incoming user question at request time and compares it against a pre-built vector index to pull the right context for an LLM.
Duplicate question detection
A support platform embeds new tickets and checks their vectors against recent ones to flag likely duplicates before an agent responds.
Lightweight semantic tagging
A content team embeds article titles to automatically cluster them into topics without hand-maintaining a taxonomy.
FAQ
What can I use the resulting vectors for?
Semantic search, clustering, deduplication, recommendation scoring and RAG retrieval are the most common uses; the vector itself is generic and works with any downstream comparison logic.
Do I need to know how vector search works to use this?
No, you only need to store and compare the returned vectors with a distance metric like cosine similarity; the embedding logic itself is handled for you.
Is my text stored after embedding?
No, submitted text and results are deleted after the retention window and are never used for training.
Why does keyword search miss results that embeddings find?
Keyword search matches characters, not intent. A query for 'cancel my plan' misses a document that only says 'terminate subscription', while the embeddings of both phrases sit close together because they mean the same thing.
Can I convert several texts in one request?
Yes. Send a list of texts instead of a single one and you get one vector for each. Every vector comes back with a usage record, so you can see what each conversion consumed.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/search/embed \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"El gato está en la alfombra."}'const res = await fetch("https://api.kit.forhosting.com/search/embed", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "El gato está en la alfombra."
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/search/embed",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "El gato está en la alfombra."
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/search/embed", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"El gato está en la alfombra."}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"El gato está en la alfombra."}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/search/embed", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "El gato está en la alfombra."
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "search.embed",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_chunks | 10000 |
max_tokens | 20000 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
This endpoint does that conversion on demand, so your own retrieval, clustering or recommendation logic has coordinates to work with instead of raw strings.
What happens when you call it
There's no model to host, no GPU to provision, and no library version to keep patched — you send text, you get coordinates back, and the infrastructure behind that stays entirely our problem. POST /search/embed with a string, get back a task_id, and receive the resulting vector by webhook or a signed 24-hour link once the job finishes.
A short history worth knowing
Vector representations of words go back to distributional semantics research from the 2000s and took off with word2vec in 2013, then moved from single words to full sentences and passages as transformer models matured. What used to require training a custom model is now a single API call, which is the whole point of exposing it this way rather than shipping a library.
One vector, many uses
A single embedding call is rarely the end goal — it's usually the first step before a similarity search, a clustering pass, or a classification model trained on top of the vectors. That's why the endpoint returns just the vector and a usage record, with no assumptions baked in about what you'll do with it next.
Where it fits in a real system
Because pricing is per request plus per 1000 tokens with no subscription tier beyond an active balance, cost tracks usage exactly, whether you're embedding ten queries a day or ten thousand.
Integration use cases
Custom recommendation scoring
An e-commerce team embeds product descriptions once and stores the vectors to power its own similarity ranking, separate from any of our indexing endpoints.
Technical questions
How do I generate a text embedding with the API?
Send your text to POST /search/embed, store the returned task_id, and retrieve the vector by webhook or a signed link valid for 24 hours.
Is the text embeddings API free?
No, there's no free tier or trial; it costs $0.002 per request plus $0.002 per 1000 tokens, and a failed task is never charged.
How is this different from search.index_text?
This endpoint returns a raw vector for a single piece of text for you to store and query yourself; search.index_text chunks, embeds and stores content in a ready-to-query index on our side.
Is there a token limit per request?
Yes, check the endpoint reference for the current maximum; for longer documents, split the text or use the batch or indexing endpoints instead.
Can I embed non-English text?
Yes, the endpoint accepts text in multiple languages and returns a vector in the same shared embedding space regardless of source language.