> **Building with AI coding agents?** Install the authstack plugin with one command. This equips your agent with accurate Scalekit implementation patterns.
>
> **Recommended** (the `-y` flags skip prompts, so the command runs without an interactive terminal):
> ```bash
> npx -y @scalekit-inc/cli setup -y
> ```
>
> Global:
> ```bash
> npm install -g @scalekit-inc/cli
> scalekit setup -y
> ```
>
> Supports Claude Code, Cursor, GitHub Copilot, Codex + skills for other Agent Skills-compatible agents in `~/.agents/skills`.
> Skills: integrate-agentkit, implement-saaskit, add-mcp-oauth, implement-sso, implement-scim.
> [Full setup guide](https://docs.scalekit.com/dev-kit/build-with-ai/)

---

# Connect AI agents to Jina AI

The Jina AI connector lets your AI agent act in each user's Jina AI account. Each user connects their own Jina AI access token once, and Scalekit sends it with every call, so your agent never handles credentials. It comes with 18 tools.

**Authentication:** Bearer Token
**Categories:** AI, Search
**Tools:** 18: 15 read, 2 write, 1 destructive
**Users sign in with:** Access token
**Built by:** Scalekit connector
**Try it:** [Playground in the Scalekit dashboard](https://app.scalekit.com/ws/signup?sk_intent=playground&provider=JINAAI)

## Setup

1. ### Install the SDK

   **Node.js**

   ```bash
   npm install @scalekit-sdk/node dotenv
   ```

   **Python**

   ```bash
   pip install scalekit-sdk-python python-dotenv
   ```

2. ### Set your credentials

   Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**.

   ```sh title=".env"
   SCALEKIT_ENVIRONMENT_URL=<your-environment-url>
   SCALEKIT_CLIENT_ID=<your-client-id>
   SCALEKIT_CLIENT_SECRET=<your-client-secret>
   ```

3. ### Create the Jina AI connection

   In **AgentKit > Connections**, create a Jina AI connection. The name you give it is the `connection_name` your code passes. See [Configure connections](/agentkit/connections/).

4. ### Authorize a user and make your first call

   **Node.js** (`quickstart.mts`)

   ```typescript
   import { ScalekitClient } from '@scalekit-sdk/node'
   import 'dotenv/config'
   import { createInterface } from 'node:readline/promises'

   const scalekit = new ScalekitClient(
     process.env.SCALEKIT_ENVIRONMENT_URL,
     process.env.SCALEKIT_CLIENT_ID,
     process.env.SCALEKIT_CLIENT_SECRET,
   )
   const actions = scalekit.actions

   const connector = 'jinaai'
   const identifier = 'user_123'

   // Generate an authorization link for the user
   const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier })
   console.log('Authorize Jina AI:', link)
   const rl = createInterface({ input: process.stdin, output: process.stdout })
   await rl.question('Press Enter after authorizing...')
   rl.close()

   // Make your first call
   const result = await actions.executeTool({
     connector,
     identifier,
     toolName: 'jinaai_embedding_batches_list',
     toolInput: {},
   })
   console.log(result)
   ```

   ```bash
   npx tsx quickstart.mts
   ```

   **Python** (`quickstart.py`)

   ```python
   import os
   from scalekit import ScalekitClient
   from dotenv import load_dotenv
   load_dotenv()

   scalekit_client = ScalekitClient(
       env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"),
       client_id=os.getenv("SCALEKIT_CLIENT_ID"),
       client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"),
   )
   actions = scalekit_client.actions

   connection_name = "jinaai"
   identifier = "user_123"

   # Generate an authorization link for the user
   link_response = actions.get_authorization_link(
       connection_name=connection_name,
       identifier=identifier,
   )
   print("Authorize Jina AI:", link_response.link)
   input("Press Enter after authorizing...")

   # Make your first call
   result = actions.execute_tool(
       tool_input={},
       tool_name="jinaai_embedding_batches_list",
       connection_name=connection_name,
       identifier=identifier,
   )
   print(result)
   ```

   ```bash
   python quickstart.py
   ```

   Each user opens the link once and enters their Jina AI credentials there. See [Authorize a user](/agentkit/tools/authorize/) for the full flow and statuses.

## Tools

Pass the exact name to `execute_tool`, with an input like each tool's example. To ask for a tool that's missing, use the [request form](https://scalekitsupport.portal.usepylon.com/forms/request-a-connector-tool).

**Node.js**

```typescript
const result = await actions.executeTool({
  toolName: 'jinaai_deepsearch_chat',
  toolInput: {
    messages: [{
        role: 'user',
        content: 'What is the latest blog post from Jina AI?',
      }],
  },
  connector: 'jinaai',
  identifier: 'user_123',
})
```

**Python**

```python
result = actions.execute_tool(
    tool_name="jinaai_deepsearch_chat",
    tool_input={
        "messages": [{
                "role": "user",
                "content": "What is the latest blog post from Jina AI?",
            }],
    },
    connection_name="jinaai",
    identifier="user_123",
)
```

`result.data` is the app's response as JSON, and `result.execution_id` (`executionId` in Node.js) is the ID of the call.

### `jinaai_deepsearch_chat`

DeepSearch · Read-only

Answer a research question with Jina DeepSearch, which searches the web, reads pages and reasons over several rounds before answering.
Returns an OpenAI-style chat completion: choices[0].message.content holds the final answer with its cited source URLs, plus usage.
Use this for questions that need several searches and sources. It can take minutes; use reasoning_effort low for speed. Use jinaai_web_search for a single quick search.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `messages` (`array`, required): Conversation so far, OpenAI chat format, ending with the user's question. Each message has role (user or assistant) and content. Example: [{"role": "user", "content": "What is the latest blog post from Jina AI?"}]
- `bad_hostnames` (`array`, optional): Domains to exclude from sources. Example: ["spam-site.example"]
- `boost_hostnames` (`array`, optional): Domains to prefer when reading sources. Example: ["jina.ai"]
- `budget_tokens` (`integer`, optional): Maximum tokens the whole research process may use; overrides reasoning_effort. Example: 200000
- `max_attempts` (`integer`, optional): Maximum attempts at solving the question with different strategies; overrides reasoning_effort. Example: 1
- `max_returned_urls` (`integer`, optional): Maximum number of source URLs in the final answer. Example: 5
- `model` (`string`, optional): DeepSearch model (default jina-deepsearch-v1). Example: jina-deepsearch-v1. Default: `jina-deepsearch-v1`.
- `no_direct_answer` (`boolean`, optional): Set true to force further search and reasoning steps even when the question looks trivial.
- `only_hostnames` (`array`, optional): Only read sources from these domains. Example: ["arxiv.org"]
- `reasoning_effort` (`string`, optional): How hard DeepSearch works: low, medium (default) or high. Lower is faster and cheaper. Example: low. One of: `low`, `medium`, `high`.
- `response_format` (`object`, optional): Structured output: {"type": "json_schema", "json_schema": <JSON schema>} makes the final answer match that schema. Example: {"type": "json_schema", "json_schema": {"type": "object", "properties": {"year": {"type": "number"}}}}

Example input: `{"messages":[{"role":"user","content":"What is the latest blog post from Jina AI?"}]}`

### `jinaai_document_transcribe`

Transcribe Document Image · Read-only

Transcribe one document page image to text or markdown with Jina's jina-ocr-v1 model, or extract fields into a JSON schema.
Returns an OpenAI-style chat completion; choices[0].message.content holds the transcription, plus usage.
Use this for a scanned page or photo you have as an image. Use jinaai_url_read with respond_with jina-ocr-v1 for a page or PDF at a URL.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `image_url` (`string`, required): Page image to transcribe: a public image URL or a data URL (data:image/png;base64,...). Example: https://example.com/invoice-page-1.png
- `max_completion_tokens` (`integer`, optional): Maximum tokens in the transcription. Example: 4096
- `prompt` (`string`, optional): Optional instruction sent with the image. Example: Transcribe this page as markdown.
- `response_format` (`object`, optional): Optional structured output: {"type": "json_schema", "json_schema": {"name": "invoice", "schema": <JSON schema>}} returns the transcription as JSON matching the schema. Example: {"type": "json_schema", "json_schema": {"name": "invoice", "schema": {"type": "object", "properties": {"total": {"type": "string"}}}}}

Example input: `{"image_url":"<image_url>"}`

### `jinaai_documents_rerank`

Rerank Documents · Read-only

Order a list of documents by how relevant each one is to a query, with a Jina reranker model.
Returns results sorted by relevance, each with index (position in your list), relevance_score and, by default, the document; plus usage.total_tokens.
Use this to refine search results or RAG chunks. Use jinaai_web_search to get candidates from the web first.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `documents` (`array`, required): Candidate documents to rank. Each is a string, or an object such as {"text": "..."} or, for jina-reranker-m0, {"image": "<image URL or base64>"}. Example: ["Organic skincare for sensitive skin with aloe vera", "New makeup trends focus on bold colors"]
- `model` (`string`, required): Reranker model. jina-reranker-v3.5 is the newest multilingual text reranker; jina-reranker-m0 also ranks images. Example: jina-reranker-v3.5. One of: `jina-reranker-v3.5`, `jina-reranker-v3`, `jina-reranker-m0`, `jina-reranker-v2-base-multilingual`, `jina-colbert-v2`.
- `query` (`string`, required): Query to rank the documents against. Example: Organic skincare products for sensitive skin
- `return_documents` (`boolean`, optional): Whether each result includes the document text (default true). Set false to get only index and relevance_score.
- `top_n` (`integer`, optional): Number of top documents to return. Leave empty to return all of them, ranked. Example: 3

Example input: `{"documents":["Organic skincare for sensitive skin with aloe vera","New makeup trends focus on bold colors"],"model":"jina-reranker-v3.5","query":"<query>"}`

### `jinaai_embedding_batch_errors_get`

Get Embedding Batch Errors · Read-only

Download the error lines of a Jina embedding batch job.
Returns JSONL text, one line per input line that failed, with its error.
Use this when jinaai_embedding_batch_get shows stats.failed above 0.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `batch_id` (`string`, required): ID of the batch job, from jinaai_embedding_batch_create or jinaai_embedding_batches_list. Example: batch_abc123

Example input: `{"batch_id":"<batch_id>"}`

### `jinaai_embedding_batch_get`

Get Embedding Batch · Read-only

Get the status of one Jina embedding batch job.
Returns batch_id, status (pending, processing, completed, failed, expired or cancelled), stats (total, completed, failed, total_tokens), output_url, error_file_url, error and timestamps.
Use this to poll a job until it completes. Use jinaai_embedding_batches_list to find job IDs.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `batch_id` (`string`, required): ID of the batch job, from jinaai_embedding_batch_create or jinaai_embedding_batches_list. Example: batch_abc123

Example input: `{"batch_id":"<batch_id>"}`

### `jinaai_embedding_batch_output_get`

Get Embedding Batch Output · Read-only

Download the results of a completed Jina embedding batch job.
Returns the output as JSONL text, one line per input with the embedding response for that line.
Use this after jinaai_embedding_batch_get shows status completed. Large jobs return very large output.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `batch_id` (`string`, required): ID of the batch job, from jinaai_embedding_batch_create or jinaai_embedding_batches_list. Example: batch_abc123

Example input: `{"batch_id":"<batch_id>"}`

### `jinaai_embedding_batches_list`

List Embedding Batches · Read-only

List your recent Jina embedding batch jobs.
Returns an array of jobs, each with batch_id, status, model, stats and timestamps.
Use this to find a job's ID. Use jinaai_embedding_batch_get for one job.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `limit` (`integer`, optional): Maximum number of jobs to return (default 20). Example: 50. Default: `20`.

Example input: `{}`

### `jinaai_embeddings_create`

Create Embeddings · Read-only

Turn text, images or code into embedding vectors with a Jina embedding model.
Returns data (one object per input with index and embedding), the model used, and usage.total_tokens.
Use this for semantic search, clustering or similarity. For thousands of texts at once use jinaai_embedding_batch_create; to order search results use jinaai_documents_rerank.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `input` (`array`, required): Items to embed, one embedding per item. Each item is a string, or an object such as {"text": "..."} or {"image": "<image URL or base64>"} for multimodal models (jina-embeddings-v4, jina-clip-v2). Example: ["Organic skincare for sensitive skin", "Bio-Hautpflege für empfindliche Haut"]
- `model` (`string`, required): Embedding model. jina-embeddings-v5-text-small (1024 dimensions, 32K context) or -nano (768 dimensions) for text; jina-embeddings-v4 or jina-clip-v2 for text and images; jina-code-embeddings-1.5b or -0.5b for code. Use jinaai_models_list for the full catalogue. Example: jina-embeddings-v5-text-small. One of: `jina-embeddings-v5-text-small`, `jina-embeddings-v5-text-nano`, `jina-embeddings-v5-omni-small`, `jina-embeddings-v5-omni-nano`, `jina-embeddings-v4`, `jina-embeddings-v3`, `jina-clip-v2`, `jina-clip-v1`, `jina-code-embeddings-1.5b`, `jina-code-embeddings-0.5b`, `jina-colbert-v2`, `jina-embeddings-v2-base-en`, `jina-embeddings-v2-base-code`.
- `dimensions` (`integer`, optional): Truncate each embedding to this many dimensions (Matryoshka), up to the model's size. Example: 256
- `embedding_type` (`string`, optional): Encoding of the returned embeddings: float (default), base64, binary or ubinary. Example: float. One of: `float`, `base64`, `binary`, `ubinary`.
- `late_chunking` (`boolean`, optional): Set true to embed all text inputs as one sequence before splitting, so each chunk keeps the context of its neighbours (jina-embeddings-v3 and v4 only).
- `normalized` (`boolean`, optional): Whether embeddings are scaled to unit length (L2-normalized). Most models default to true.
- `task` (`string`, optional): What the embeddings are for, so the model can optimize them: retrieval.query for search queries, retrieval.passage for the documents being searched, text-matching for similarity, classification, clustering (v5), separation (v3), code.query or code.passage (v4); code models use nl2code.query, nl2code.passage, qa.query, qa.passage and similar. Example: retrieval.passage
- `truncate` (`boolean`, optional): Set true to cut inputs longer than the model's context instead of returning an error.

Example input: `{"input":["Organic skincare for sensitive skin","Bio-Hautpflege für empfindliche Haut"],"model":"jina-embeddings-v5-text-small"}`

### `jinaai_model_get`

Get Model · Read-only

Get one Jina model's details by ID.
Returns the model's id, name, modalities, context_length, max_output_length, pricing, supported features and description.
Use this when you know the model ID. Use jinaai_models_list to browse all models.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `model_id` (`string`, required): Model ID, in full (jina-ai/jina-embeddings-v3) or short (jina-embeddings-v3) form, from jinaai_models_list. Example: jina-embeddings-v5-text-small

Example input: `{"model_id":"<model_id>"}`

### `jinaai_models_list`

List Models · Read-only

List every model in Jina's catalogue.
Returns data, one entry per model with id, name, input and output modalities, context_length, pricing and description.
Use this to pick a model for embeddings, reranking or classification. Use jinaai_model_get for one model.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs: none.

Example input: `{}`

### `jinaai_text_classify`

Classify Text or Images · Read-only

Sort texts or images into categories with Jina Classifier, either zero-shot from a list of labels or with a classifier you trained.
Returns data with one entry per input: index, prediction (the best label), score, and predictions (score for every label); plus usage.total_tokens.
Use labels and model for zero-shot. Use classifier_id after jinaai_classifier_train for few-shot.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `input` (`array`, required): Items to classify. Each is an object: {"text": "..."} for text, or {"image": "<image URL or base64>"} for images (jina-clip-v2 or jina-embeddings-v4). Do not mix text and images in one call. Up to 1,024 items. Example: [{"text": "Write a poem about the beauty of nature."}, {"text": "Translate this sentence into French."}]
- `classifier_id` (`string`, optional): ID of a few-shot classifier trained with jinaai_classifier_train. When set, labels and model come from that classifier. Example: 918c0846-d6ae-4f34-810d-c0c7a59aee14
- `labels` (`array`, optional): Candidate labels for zero-shot classification, up to 256. Required unless classifier_id is set. Example: ["Creative writing", "Simple task"]
- `model` (`string`, optional): Model for zero-shot classification: jina-embeddings-v3 for text, jina-clip-v2 for images, jina-embeddings-v4 for text or images. Required unless classifier_id is set. Example: jina-embeddings-v3. One of: `jina-embeddings-v3`, `jina-embeddings-v4`, `jina-clip-v2`.

Example input: `{"input":[{"text":"Write a poem about the beauty of nature."},{"text":"Translate this sentence into French."}]}`

### `jinaai_text_segment`

Segment Text · Read-only

Count the tokens in a text with Jina Segmenter, and optionally split it into chunks or list its tokens. Free of charge.
Returns num_tokens and tokenizer, plus chunks, chunk_positions and num_chunks when return_chunks is true, and tokens when return_tokens is true.
Use this to check a text's size or to chunk text from jinaai_url_read before jinaai_embeddings_create.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `content` (`string`, required): Text to count tokens in or split into chunks, up to 64K characters. Example: Jina AI: Your Search Foundation, Supercharged!
- `head` (`integer`, optional): Return only the first N tokens. Cannot be combined with tail. Example: 100
- `max_chunk_length` (`integer`, optional): Maximum characters per chunk when return_chunks is true (default 1000); a chunk can be shorter at a natural boundary. Example: 500
- `return_chunks` (`boolean`, optional): Set true to split the text into semantic chunks, returned in chunks and chunk_positions.
- `return_tokens` (`boolean`, optional): Set true to also return the tokens and their IDs.
- `tail` (`integer`, optional): Return only the last N tokens. Cannot be combined with head. Example: 100
- `tokenizer` (`string`, optional): Tokenizer used for counting (default cl100k_base). Example: o200k_base. One of: `cl100k_base`, `o200k_base`, `p50k_base`, `r50k_base`, `p50k_edit`, `gpt2`.

Example input: `{"content":"<content>"}`

### `jinaai_url_read`

Read URL · Read-only

Fetch a web page or PDF by URL with Jina Reader and get its main content in an LLM-friendly format.
Returns JSON with data.title, data.description, data.url, the page body (data.content for markdown, the default; data.text or data.html for those formats) and data.usage.tokens, plus data.links and data.images when requested.
Use this when you already know the URL. Use jinaai_web_search to find pages first, and jinaai_url_screenshot for an image of the page.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `url` (`string`, required): Full URL of the public web page or PDF to read, including https://. Example: https://jina.ai/news
- `engine` (`string`, optional): Engine Jina Reader uses to fetch the page: browser for the best quality on JavaScript-heavy pages, direct for speed on simple pages, cf-browser-rendering for an experimental engine aimed at JavaScript-heavy sites. Leave empty to let Jina choose. Example: browser. One of: `browser`, `direct`, `cf-browser-rendering`.
- `locale` (`string`, optional): Browser locale used to render the page, for sites that serve different content per language. Example: de-DE
- `no_cache` (`boolean`, optional): Set true to bypass Jina's cache and fetch a fresh copy of the page.
- `page` (`integer`, optional): Page to parse when respond_with is jina-ocr-v1, starting at 1. A multi-page document needs one call per page. Example: 2
- `remove_selector` (`string`, optional): CSS selector for elements to strip out, such as headers, footers or navigation. Example: header, footer, nav
- `respond_with` (`string`, optional): Optional model that converts the page. readerlm-v2 converts complex HTML to markdown with a small language model. jina-ocr-v1 reads the rendered page as an image (for scanned documents, PDFs, formulas and tables), parses one page per request (see page) and costs about 40 times the tokens. Example: readerlm-v2. One of: `readerlm-v2`, `jina-ocr-v1`.
- `retain_images` (`string`, optional): Set to none to remove all images from the content and save tokens. Example: none. One of: `none`.
- `return_format` (`string`, optional): Format of the page body: markdown (default, LLM-friendly, in data.content), html (in data.html) or text (plain text, in data.text). Example: markdown. One of: `markdown`, `html`, `text`.
- `target_selector` (`string`, optional): CSS selector for the part of the page to keep; everything else is dropped. Example: article
- `timeout` (`integer`, optional): Maximum seconds to wait for the page to load, from 1 to 180. Example: 30
- `token_budget` (`integer`, optional): Maximum number of tokens the request may use; the call fails if the page is larger. Example: 50000
- `wait_for_selector` (`string`, optional): CSS selector Jina waits for before returning, for pages that load content late. Example: #main-content
- `with_generated_alt` (`boolean`, optional): Set true to have Jina write alt text for images that have none.
- `with_iframe` (`boolean`, optional): Set true to include content from iframes on the page.
- `with_images_summary` (`string`, optional): Adds the page's images in data.images: true for unique images, all for every image. Example: true. One of: `true`, `all`.
- `with_links_summary` (`string`, optional): Adds the page's links in data.links: true for unique links, all for every link. Example: true. One of: `true`, `all`.
- `with_shadow_dom` (`boolean`, optional): Set true to extract content from Shadow DOM roots in the page.

Example input: `{"url":"<url>"}`

### `jinaai_url_screenshot`

Capture URL Screenshot · Read-only

Capture a screenshot of a web page with Jina Reader.
Returns JSON with the page title and URL and a link to the PNG image in data.screenshotUrl (or data.pageshotUrl for a full-page capture).
Use this to see how a page looks. Use jinaai_url_read to get the page's text.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `url` (`string`, required): Full URL of the public web page to capture, including https://. Example: https://jina.ai
- `capture` (`string`, optional): What to capture: screenshot for the first screen (viewport) or pageshot for the full scrolling page. Example: pageshot. One of: `screenshot`, `pageshot`. Default: `screenshot`.
- `engine` (`string`, optional): Engine Jina Reader uses to fetch the page: browser for the best quality on JavaScript-heavy pages, direct for speed on simple pages, cf-browser-rendering for an experimental engine aimed at JavaScript-heavy sites. Leave empty to let Jina choose. Example: browser. One of: `browser`, `direct`, `cf-browser-rendering`.
- `locale` (`string`, optional): Browser locale used to render the page, for sites that serve different content per language. Example: de-DE
- `no_cache` (`boolean`, optional): Set true to bypass Jina's cache and fetch a fresh copy of the page.
- `timeout` (`integer`, optional): Maximum seconds to wait for the page to load, from 1 to 180. Example: 30
- `wait_for_selector` (`string`, optional): CSS selector Jina waits for before returning, for pages that load content late. Example: #main-content

Example input: `{"url":"<url>"}`

### `jinaai_web_search`

Search the Web · Read-only

Search the web with Jina Search and get the top results, each with its page content read in an LLM-friendly format.
Returns JSON with a data array; each result has title, url, description, content and usage.tokens (content is omitted when respond_with is no-content).
Use this when you don't know which page has the answer. Use jinaai_url_read for a known URL, and jinaai_deepsearch_chat for a multi-step research question.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `q` (`string`, required): Search query. Example: When was Jina AI founded?
- `gl` (`string`, optional): Two-letter country code the search runs from. Example: us
- `hl` (`string`, optional): Two-letter language code for the results. Example: en
- `locale` (`string`, optional): Browser locale used to render result pages. Example: en-US
- `location` (`string`, optional): Where the search should originate from, best given at city level. Example: San Francisco, California, United States
- `no_cache` (`boolean`, optional): Set true to bypass Jina's cache and get real-time results.
- `num` (`integer`, optional): Maximum number of results to return, up to 20. Larger values add latency. Example: 5
- `page` (`integer`, optional): Results page to return, for pagination. Example: 2
- `respond_with` (`string`, optional): Set to no-content to return only each result's title, URL and description without fetching the pages. This is much faster and uses far fewer tokens. Example: no-content. One of: `no-content`.
- `retain_images` (`string`, optional): Set to none to remove all images from the content. Example: none. One of: `none`.
- `return_format` (`string`, optional): Format of each result's content: markdown (default), html or text. Example: markdown. One of: `markdown`, `html`, `text`.
- `site` (`string`, optional): Limit results to one website or domain. Example: https://jina.ai
- `timeout` (`integer`, optional): Maximum seconds to wait for each result page to load. Example: 30
- `type` (`string`, optional): Kind of results: web (default), images or news. Example: news. One of: `web`, `images`, `news`.
- `with_favicons` (`boolean`, optional): Set true to include each result's favicon.
- `with_images_summary` (`string`, optional): Adds each page's images: true for unique images, all for every image. Example: true. One of: `true`, `all`.
- `with_links_summary` (`string`, optional): Adds each page's links: true for unique links, all for every link. Example: true. One of: `true`, `all`.

Example input: `{"q":"<q>"}`

### `jinaai_classifier_train`

Train Classifier · Write

Create a few-shot Jina classifier from labelled examples, or add examples to an existing one.
Returns the classifier_id and the number of samples trained on.
Use this when zero-shot labels are not accurate enough. Then call jinaai_text_classify with the classifier_id.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `input` (`array`, required): Labelled training examples. Each is an object with text (or image) and label. Labels are free names and need no meaning, up to 16 classes. Example: [{"text": "I can't log into my account after the update.", "label": "team1"}, {"text": "Please update my billing address.", "label": "team2"}]
- `access` (`string`, optional): Who can use a new classifier: private (default, only your API key) or public (anyone with the ID, on their own quota). Example: private. One of: `private`, `public`.
- `classifier_id` (`string`, optional): ID of an existing classifier to keep training with more examples. Leave empty to create a new classifier. Example: 918c0846-d6ae-4f34-810d-c0c7a59aee14
- `model` (`string`, optional): Embedding model the new classifier is built on. Required when creating a classifier; leave empty when updating one with classifier_id. Example: jina-embeddings-v3. One of: `jina-embeddings-v3`, `jina-embeddings-v4`, `jina-clip-v2`.
- `num_iters` (`integer`, optional): Training passes over these examples (default 10). Higher values weigh these examples more. Example: 10

Example input: `{"input":[{"text":"I can't log into my account after the update.","label":"team1"},{"text":"Please update my billing address.","label":"team2"}]}`

### `jinaai_embedding_batch_create`

Create Embedding Batch · Write

Submit a large set of texts as an asynchronous Jina embedding batch job.
Returns the job's batch_id, status (pending at first), model and created_at.
Use this for thousands of texts. Poll with jinaai_embedding_batch_get, then read results with jinaai_embedding_batch_output_get. Use jinaai_embeddings_create for a few texts now.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `model` (`string`, required): Embedding model for the batch. Example: jina-embeddings-v5-text-small. One of: `jina-embeddings-v5-text-small`, `jina-embeddings-v5-text-nano`.
- `dimensions` (`integer`, optional): Truncate each embedding to this many dimensions, 1 to 1024. Example: 256
- `input` (`array`, optional): Inline input lines for smaller batches (up to 10,000). Each line is an object with a custom_id and the text under body.input, not a bare {input: text}. Provide input or input_url. Example: [{"custom_id": "doc-1", "body": {"input": "First document text"}}, {"custom_id": "doc-2", "body": {"input": "Second document text"}}]
- `input_url` (`string`, optional): URL of a JSONL input file (GCS, S3 or HTTP), one {"custom_id": "doc-1", "body": {"input": "text"}} object per line. Provide input or input_url. Example: gs://my-bucket/docs.jsonl
- `normalized` (`boolean`, optional): Whether embeddings are L2-normalized (default true).
- `task` (`string`, optional): What the embeddings are for (default text-matching). Example: retrieval.passage. One of: `retrieval.query`, `retrieval.passage`, `text-matching`, `classification`, `clustering`.
- `webhook_url` (`string`, optional): URL Jina POSTs to when the job completes. Example: https://example.com/hooks/jina-batch

Example input: `{"model":"jina-embeddings-v5-text-small"}`

### `jinaai_embedding_batch_cancel`

Cancel Embedding Batch · Destructive

Cancel a pending or processing Jina embedding batch job.
Returns the job with its updated status.
Use this to stop a job you no longer need. Completed jobs cannot be cancelled.

Read only: no. Destructive: yes. Idempotent (safe to retry): yes.

Inputs:

- `batch_id` (`string`, required): ID of the batch job, from jinaai_embedding_batch_create or jinaai_embedding_batches_list. Example: batch_abc123

Example input: `{"batch_id":"<batch_id>"}`

## Related

Other AI connectors ([all 216](/agentkit/connectors/?category=ai)):

- [Chorus](/agentkit/connectors/chorus/): Scalekit connector, Username and password, 9 tools
- [Gong](/agentkit/connectors/gong/): Scalekit connector, OAuth, 69 tools
- [Jiminny](/agentkit/connectors/jiminny/): Scalekit connector, Access token, 27 tools


---

## More Scalekit documentation

| Resource | What it contains | When to use it |
|----------|-----------------|----------------|
| [/llms.txt](/llms.txt) | Structured index with routing hints per product area | Start here — find which documentation set covers your topic before loading full content |
| [/llms-full.txt](/llms-full.txt) | Complete documentation for all Scalekit products in one file | Use when you need exhaustive context across multiple products or when the topic spans several areas |
| [sitemap-0.xml](https://docs.scalekit.com/sitemap-0.xml) | Full URL list of every documentation page | Use to discover specific page URLs you can fetch for targeted, page-level answers |
