Jina Reranker

Weights + hosted API · Jina AI, now part of Elastic · Updated 12 Oct 2026

Jina’s current flagship is jina-reranker-v3.5, announced August 2026: a 0.6B listwise reranker built on Qwen3-0.6B and a drop-in upgrade to v3 — same API, 131K-token context, and 1.22–1.56× faster. In Jina’s own evaluation it scores 63.20* nDCG@10 on BEIR, just above Qwen3-Reranker-4B at about a seventh of the size, though the 4B still leads on multilingual, professional-domain and structured retrieval. The catch for self-hosting: the v2, v3 and v3.5 weights are CC BY-NC 4.0 — non-commercial. v1-tiny (Apache 2.0) is still what runs in our browser demo.

Model variants

Parameter counts and licences from each model’s Hugging Face page (Oct 2026). jina-reranker-v1-base-en, listed here until then, is no longer public on Hugging Face.

What listwise v3 and v3.5 change

Classic cross-encoders score each (query, doc) independently. Listwise models see a slate of candidates at once, which can improve relative ordering when many passages share vocabulary. The trade-off is higher memory and a different serving path than MiniLM-style pair scoring.

v3 introduced what Jina call last but not late interaction: the query and every candidate run through causal self-attention as one sequence, and each document’s score is the cosine between projected embeddings taken at special token positions — so documents are judged in the context of each other, not just the query. v3.5 keeps that and replaces uniform global attention with a schedule of three sliding-window layers (1,024-token windows) followed by two global layers, with the final layer always global. It adds legal, medical, financial and structured-data training, and distils from a same-size full-attention teacher. Jina measure 1.22× lower latency on short passages and 1.56× on long ones (A100, top-100 lists). Details in the v3.5 paper and the v3 paper.

Whose benchmark?

For v3.5, Jina re-ran every model under one protocol: 13 BEIR datasets, MIRACL across 18 languages, RTEB (legal, finance, code, medical) and Struct-IR, each reranking the top 100 candidates from jina-embeddings-v5-text-small.

nDCG@10, from the jina-reranker-v3.5 model card. Struct-IR uses a controlled candidate pool (all gold documents plus the 30 hardest distractors), so it isn’t comparable to other Struct-IR leaderboards.

v3.5 leads on BEIR, by under a point. On the other three the 4B is ahead, which Jina’s own write-up says plainly. The v3 paper’s 2025 run, over a different first-stage retriever, had v3 at 61.94* and Qwen3-Reranker-4B at 61.16*. That is where “v3 beats Qwen3-Reranker-4B”, repeated on this site until October 2026, came from; on the newer run it no longer holds. Qwen3-Reranker-4B moving by more than a point between two runs from the same vendor is a good reason to read BEIR averages as tiers rather than rankings.

Licence: what you can self-host

The v2, v3, v3.5 and m0 weights are released under CC BY-NC 4.0: free to download and evaluate, not to use commercially. For production there are three routes: Jina’s hosted API, billed per token; for v3.5, Elastic Inference Service (Elastic Stack 9.3 and later); or a commercial licence, which Jina now arrange through Elastic’s sales team. Jina also list v3 on the Azure and Google Cloud marketplaces. Only the legacy v1 English models are Apache 2.0.

If you need commercially permissive open weights at a similar level, Qwen3-Reranker, mxbai-rerank-v2 and bge-reranker-v2 are all Apache 2.0.

Pricing

Jina bill the reranker by token, from the same balance as their other APIs. New API keys come with free tokens to try it; after that you buy token packages. Jina changed their pricing on 6 May 2025, and their site shows current package prices only once the page has loaded in a browser, so we don’t quote a figure here — check jina.ai/reranker before you budget.

Rate limits from the jina.ai/reranker FAQ, shared with the Embeddings API. The API accepts up to 131,072 tokens per request (query plus all documents) for v3 and v3.5, truncating beyond that. On latency, the same FAQ puts 100 documents of 256 tokens with a 64-token query at about 150 ms, rising to 3.5 s with 4,096-token documents and 7 s if the query is also 512 tokens.

Quick start

Hosted API (Python)

import requests

def rerank(query: str, documents: list[str], top_n: int = 5) -> list[str]:
    resp = requests.post(
        "https://api.jina.ai/v1/rerank",
        headers={"Authorization": "Bearer YOUR_KEY", "Content-Type": "application/json"},
        json={
            "model": "jina-reranker-v3.5",  # or jina-reranker-v3; same request schema
            "query": query,
            "documents": documents,
            "top_n": top_n,
        },
    ).json()
    return [documents[r["index"]] for r in resp["results"]]

Self-hosted (transformers)

Non-commercial use only, unless you have a licence — see above.

from transformers import AutoModel

model = AutoModel.from_pretrained(
    "jinaai/jina-reranker-v3.5",
    dtype="auto",
    trust_remote_code=True,
)
model.eval()

# Listwise: all documents are scored together, in one forward pass
results = model.rerank(query, documents, top_n=5)
for r in results:
    print(f"{r['relevance_score']:.4f}  {r['document'][:80]}")

Browser / edge use

The v1-tiny model (33M parameters) runs in the browser via transformers.js. On a 4-vCPU GitHub Actions runner, the demo’s first run — download plus scoring 10 passages — took 4.6 s, and later runs scored 10 passages in 229 ms and 30 in 672 ms. That is with the demo page cross-origin isolated, which lets ONNX Runtime score on several threads; a browser that doesn’t support the isolation header runs single-threaded, about half as fast. A phone or older laptop will be slower too; the demo shows the time for each run on your own device. This is what powers it:

// transformers.js (ES module in the browser)
import { AutoTokenizer, AutoModelForSequenceClassification }
  from "https://cdn.jsdelivr.net/npm/@huggingface/transformers@4";

const tokenizer = await AutoTokenizer.from_pretrained(
  "jinaai/jina-reranker-v1-tiny-en", { dtype: "q8" }
);
const model = await AutoModelForSequenceClassification.from_pretrained(
  "jinaai/jina-reranker-v1-tiny-en", { dtype: "q8" }
);

const inputs = tokenizer([query, query], {
  text_pair: [doc1, doc2],
  padding: true, truncation: true,
});
const { logits } = await model(inputs);
const scores = logits.sigmoid().tolist();

Pros and cons

Other models