# Jentic

> Call thousands of APIs through Jentic One, the execution layer that keeps API keys away from agents: search for an operation, read its inputs, and call it with a stored credential under permission rules you set, with every call recorded.

App · AI Agents · 11 actions. Web page: https://docs.lodol.com/docs/integrations/jentic

## Actions

### Call an API operation

Call an operation of any imported API through Jentic One's broker, which checks the agent's permission rules, adds the stored credential and records the call. The workflow never holds the API's key.

**Inputs**

- Operation (`operation`, text, required): The operation: its id from 'Search for an API operation' (op_...), or its method and address, such as GET https://api.example.com/v1/items/{id}.
- Address inputs (`path_parameters`, object): Values for the {placeholders} in the operation's address, such as {"id": "123"}.
- Query inputs (`query_parameters`, object): Inputs sent after the '?' in the address, such as {"limit": 10}.
- Body (`body`, object): The request body. An object or a list is sent as JSON; text is sent as it is.
- Headers (`headers`, object): Extra headers for the API. Leave out authorization: Jentic adds the stored credential itself.
- Credential (`credential`, text): Which credential to use, when several cover the same API: pick it, or enter its name. On Jentic One 0.39, which groups credentials into toolkits, pick the toolkit. Leave empty to let Jentic choose.
- Idempotency key (`idempotency_key`, text): Any unique text. Jentic answers a repeat of the same call with the same key for a day from its record, rather than calling the API twice. It keeps a repeated answer's body only up to 256 KB.
- If the call fails (`on_error`, text): What to do when the API answers with an error status. Continuing lets later steps check the status themselves, which suits a 404 that just means not found. One of: `fail` (Stop the workflow), `continue`. Default: `fail`.

**Outputs**

- `api_vendor` (text): The vendor of the API called.
- `body` (object): What the API sent back: JSON as data, text as text.
- `body_base64` (text): A body that is neither JSON nor text, such as an image, base64-encoded.
- `body_omitted` (true/false): Whether a replayed answer comes without its body, because Jentic keeps bodies only up to 256 KB for replays.
- `content_type` (text): The type of what the API sent back.
- `credential_id` (text): The stored credential Jentic signed the call with.
- `credential_name` (text): That credential's name.
- `execution_id` (text): Jentic's record of this call. 'Get an execution record' reads it.
- `headers` (object): The API's response headers, names in lower case.
- `ok` (true/false): Whether the status is 2xx.
- `operation` (text): The call that was made: its method and full address.
- `operation_id` (text): Jentic's id for the operation called.
- `replayed` (true/false): Whether this is the first answer again, replayed for a repeated idempotency key instead of calling the API.
- `status` (number): The HTTP status the API answered with.
- `toolkit_id` (text): On Jentic One 0.39: the toolkit the call went through.

**Example output**

```json
{
  "api_vendor": "httpbin-org",
  "body": {
    "args": {
      "source": "lodol"
    },
    "url": "https://httpbin.org/get?source=lodol"
  },
  "body_base64": null,
  "body_omitted": false,
  "content_type": "application/json",
  "credential_id": "cred_6ab424f2d40a1d10673d465d",
  "credential_name": "httpbin",
  "execution_id": "exec_f85d6a6eefe04505bd78dc16",
  "headers": {
    "content-type": "application/json"
  },
  "ok": true,
  "operation": "GET https://httpbin.org/get?source=lodol",
  "operation_id": "op_cfd40be31965a3a20ec40bae1261d9569ad00673",
  "replayed": false,
  "status": 200,
  "toolkit_id": null
}
```

### Check a background job

See whether a background job has finished, such as an import still running when its step ended, and get what it produced: the imported APIs for an import, the API's answer for a call.

**Inputs**

- Job (`job_id`, text, required): The job's id, as 'Import an API from the catalog' gave it back.

**Outputs**

- `apis` (list): For a finished import: the APIs it added.
- `body` (object): For a finished call: what the API sent back.
- `body_base64` (text): A body that is neither JSON nor text, base64-encoded.
- `content_type` (text): The type of what the API sent back.
- `created_at` (text): When it was queued.
- `error` (text): What went wrong, including why a call never reached the API. A job still running can carry one while it retries.
- `execution_id` (text): For a call: Jentic's record of it.
- `is_finished` (true/false): Whether nothing more will happen to it.
- `job_id` (text): The job's id.
- `kind` (text): import for an import, execution for a queued call.
- `ok` (true/false): For a finished call: whether that status is 2xx, false when the call never reached the API.
- `status` (text): queued, running, completed, failed, cancelled or dead_letter, or unchanged for an import that found the API already up to date.
- `status_code` (number): For a finished call: the HTTP status the API answered with.
- `updated_at` (text): When it last changed.

**Example output**

```json
{
  "apis": [
    {
      "api_id": "httpbin-org/httpbin-org/0.9.2",
      "host": null,
      "name": "httpbin-org",
      "revision_id": "20308cb1-ed0a-4a30-9c9f-719a70850435",
      "state": "imported",
      "vendor": "httpbin-org",
      "version": "0.9.2"
    }
  ],
  "body": null,
  "body_base64": null,
  "content_type": null,
  "created_at": "2026-09-23T19:15:40Z",
  "error": null,
  "execution_id": null,
  "is_finished": true,
  "job_id": "job_6ab4255c5d13c357f978469b",
  "kind": "import",
  "ok": null,
  "status": "completed",
  "status_code": null,
  "updated_at": "2026-09-23T19:15:52Z"
}
```

### Get an execution record

Read Jentic One's record of a brokered call: whether it succeeded, the status the API answered with, how long it took and which credential signed it. Bodies are not kept.

**Inputs**

- Execution (`execution_id`, text, required): The record's id, as 'Call an API operation' gave it back.

**Outputs**

- `actor_id` (text): The agent or person who made it.
- `api` (object)
- `credential_id` (text): The stored credential used.
- `credential_name` (text): That credential's name.
- `duration_ms` (number): How long the call took, in milliseconds.
- `error` (text): What went wrong, when the call failed.
- `execution_id` (text): The record's id.
- `http_status` (number): The HTTP status the API answered with.
- `ok` (true/false): Whether that status is 2xx.
- `operation_id` (text): The operation called.
- `origin` (text): How it was made: api, mcp, cli, dashboard, agent or system.
- `started_at` (text): When the call started.
- `status` (text): completed or failed.
- `trace_id` (text): The trace id, for matching against logs.

**Example output**

```json
{
  "actor_id": "agnt_6ab424eb2c3970e5efec4327",
  "api": {
    "api_id": "httpbin-org/httpbin-org/0.9.2",
    "host": null,
    "name": "httpbin-org",
    "vendor": "httpbin-org",
    "version": "0.9.2"
  },
  "credential_id": "cred_6ab424f2d40a1d10673d465d",
  "credential_name": "httpbin",
  "duration_ms": 184,
  "error": null,
  "execution_id": "exec_f85d6a6eefe04505bd78dc16",
  "http_status": 200,
  "ok": true,
  "operation_id": "op_cfd40be31965a3a20ec40bae1261d9569ad00673",
  "origin": "api",
  "started_at": "2026-09-23T19:15:29Z",
  "status": "completed",
  "trace_id": "e0214e3d280ab5ba4132f01e592d36fe"
}
```

### Get an operation's inputs

Read everything an operation takes before calling it: the placeholders in its address, its query and header inputs and the body it expects, each marked required or not.

**Inputs**

- Operation (`operation`, text, required): The operation: its id from 'Search for an API operation' (op_...), or its method and address, such as GET https://api.example.com/v1/items/{id}.

**Outputs**

- `api` (object)
- `body` (object): The request body it takes, if any.
- `description` (text): What the operation does.
- `header_parameters` (list): Inputs sent as headers.
- `method` (text): The HTTP method.
- `name` (text): The operation's summary.
- `operation` (text): The method and address together.
- `operation_id` (text): Jentic's id for the operation.
- `path_parameters` (list): Inputs that fill the {placeholders} in the address.
- `query_parameters` (list): Inputs sent after the '?'.
- `server` (text): The base address the API is served from.
- `url` (text): The upstream address, with {placeholders} for path inputs.

**Example output**

```json
{
  "api": {
    "description": null,
    "name": "httpbin-org",
    "vendor": "httpbin-org",
    "version": "0.9.2"
  },
  "body": null,
  "description": null,
  "header_parameters": [],
  "method": "GET",
  "name": "The request's query parameters.",
  "operation": "GET https://httpbin.org/get",
  "operation_id": "op_cfd40be31965a3a20ec40bae1261d9569ad00673",
  "path_parameters": [],
  "query_parameters": [],
  "server": "https://httpbin.org",
  "url": "https://httpbin.org/get"
}
```

### Get the agent's access

See what this connection can reach in Jentic One: the agent's credentials (or its toolkits, on Jentic One 0.39), the APIs they serve, its scopes, and where calls are sent. Changes nothing, so it also makes a good first step for checking the connection.

**Inputs**: None.

**Outputs**

- `actor_type` (text): agent, for an agent key.
- `agent_id` (text): The agent this connection acts as.
- `agent_name` (text): Its name in the console.
- `api_count` (number): How many APIs that is.
- `apis_served` (list): Every API the agent can call, as ids for 'Search for an API operation'.
- `can_call_apis` (true/false): Whether it may call APIs through the broker.
- `credential_count` (number): How many there are.
- `credentials` (list): The stored credentials bound to the agent. Empty on Jentic One 0.39, which binds toolkits instead.
- `instance` (object)
- `scopes` (list): What the agent may do.
- `status` (text): active, or disabled if it has been switched off.
- `toolkit_count` (number): How many there are.
- `toolkits` (list): On Jentic One 0.39: the toolkits bound to the agent.
- `warning` (text): Why the instance's own details are missing, if they are.

**Example output**

```json
{
  "actor_type": "agent",
  "agent_id": "agnt_6ab424eb2c3970e5efec4327",
  "agent_name": "Lodol",
  "api_count": 1,
  "apis_served": [
    "httpbin-org/httpbin-org/0.9.2"
  ],
  "can_call_apis": true,
  "credential_count": 1,
  "credentials": [
    {
      "bound_at": "2026-09-23T19:14:10",
      "credential_id": "cred_6ab424f2d40a1d10673d465d",
      "name": "httpbin",
      "serves": [
        {
          "api_id": "httpbin-org/httpbin-org/0.9.2",
          "name": "httpbin-org",
          "vendor": "httpbin-org",
          "version": "0.9.2"
        }
      ],
      "suspended": false
    }
  ],
  "instance": {
    "backend": "local",
    "base_url": "https://jentic.example.com",
    "broker_url": "https://broker.jentic.example.com"
  },
  "scopes": [
    "apis:read",
    "capabilities:execute",
    "executions:read",
    "jobs:read"
  ],
  "status": "active",
  "toolkit_count": 0,
  "toolkits": [],
  "warning": null
}
```

### Import an API from the catalog

Import an API from Jentic's public catalog so its operations can be searched and called. An API already imported, with nothing newer in the catalog, is left as it is. Calling it still needs a credential for it bound to the agent in the console, through a toolkit on Jentic One 0.39.

**Inputs**

- Catalog API (`api_id`, text, required): The API's catalog id, such as httpbin.org or googleapis.com/gmail. 'Search the API catalog' gives it.
- Wait up to (`wait_seconds`, number): Seconds to wait for the import to finish. A longer import hands back its job to check later. From 0 to 120. Default: `60`.

**Outputs**

- `already_imported` (true/false): Whether the catalog had nothing newer to import.
- `api_id` (text): The catalog id imported.
- `apis` (list): The imported APIs; pass an api_id to the other steps.
- `is_finished` (true/false): Whether the import has finished.
- `job_id` (text): The import job, when one ran. 'Check a background job' follows it.
- `status` (text): completed, unchanged when it was already imported, or the job's status if it is still running.

**Example output**

```json
{
  "already_imported": false,
  "api_id": "httpbin.org",
  "apis": [
    {
      "api_id": "httpbin-org/httpbin-org/0.9.2",
      "host": null,
      "name": "httpbin-org",
      "revision_id": "20308cb1-ed0a-4a30-9c9f-719a70850435",
      "state": "imported",
      "vendor": "httpbin-org",
      "version": "0.9.2"
    }
  ],
  "is_finished": true,
  "job_id": "job_6ab425f18372e6d551f54e44",
  "status": "completed"
}
```

### List an API's operations

List every operation of one imported API: its method, path, summary and id, ready to pass to 'Call an API operation'.

**Inputs**

- API (`api`, text, required): The imported API, as vendor/name/version. 'List imported APIs' gives each one's id.
- At most (`limit`, number): The most operations to return. From 1 to 200. Default: `50`.
- Continue from (`cursor`, text): The previous step's 'next_cursor', to get the next page.

**Outputs**

- `api_id` (text): The API listed.
- `has_more` (true/false): Whether more results follow this page.
- `next_cursor` (text): Pass this as 'Continue from' in the same step to get the next page.
- `operation_count` (number): How many came back.
- `operations` (list): The API's operations.

**Example output**

```json
{
  "api_id": "httpbin-org/httpbin-org/0.9.2",
  "has_more": false,
  "next_cursor": null,
  "operation_count": 1,
  "operations": [
    {
      "deprecated": false,
      "description": null,
      "method": "GET",
      "name": "The request's query parameters.",
      "operation_id": "op_cfd40be31965a3a20ec40bae1261d9569ad00673",
      "path": "/get",
      "tags": [
        "HTTP Methods"
      ]
    }
  ]
}
```

### List executions

List the calls made through Jentic One, newest first, with their outcome, status, duration and credential. Filter by outcome, API or time to find the failures to follow up.

**Inputs**

- Only (`status`, list): Only calls that ended this way. Both if unset. One or more of: `completed`, `failed`.
- API (`api`, text): Only calls to this imported API.
- Started on or after (`started_after`, date and time): Only calls from this moment on.
- Started on or before (`started_before`, date and time): Only calls up to this moment.
- At most (`limit`, number): The most calls to return. From 1 to 100. Default: `25`.
- Continue from (`cursor`, text): The previous step's 'next_cursor', to get the next page.

**Outputs**

- `execution_count` (number): How many came back.
- `executions` (list): The calls, newest first.
- `failed_count` (number): How many of those failed.
- `has_more` (true/false): Whether more results follow this page.
- `next_cursor` (text): Pass this as 'Continue from' in the same step to get the next page.

**Example output**

```json
{
  "execution_count": 1,
  "executions": [
    {
      "actor_id": "agnt_6ab424eb2c3970e5efec4327",
      "api": {
        "api_id": "httpbin-org/httpbin-org/0.9.2",
        "host": null,
        "name": "httpbin-org",
        "vendor": "httpbin-org",
        "version": "0.9.2"
      },
      "credential_id": "cred_6ab424f2d40a1d10673d465d",
      "credential_name": "httpbin",
      "duration_ms": 184,
      "error": null,
      "execution_id": "exec_f85d6a6eefe04505bd78dc16",
      "http_status": 200,
      "ok": true,
      "operation_id": "op_cfd40be31965a3a20ec40bae1261d9569ad00673",
      "origin": "api",
      "started_at": "2026-09-23T19:15:29Z",
      "status": "completed",
      "trace_id": "e0214e3d280ab5ba4132f01e592d36fe"
    }
  ],
  "failed_count": 0,
  "has_more": false,
  "next_cursor": null
}
```

### List imported APIs

List the APIs imported into Jentic One, each with the id the other steps take, its number of operations, how it authenticates, and whether the catalog has a newer description.

**Inputs**

- Vendor (`vendor`, text): Only this vendor's APIs, such as stripe.com.
- At most (`limit`, number): The most APIs to return. From 1 to 200. Default: `50`.
- Continue from (`cursor`, text): The previous step's 'next_cursor', to get the next page.

**Outputs**

- `api_count` (number): How many came back.
- `apis` (list): The imported APIs.
- `has_more` (true/false): Whether more results follow this page.
- `next_cursor` (text): Pass this as 'Continue from' in the same step to get the next page.

**Example output**

```json
{
  "api_count": 1,
  "apis": [
    {
      "api_id": "httpbin-org/httpbin-org/0.9.2",
      "catalog_api_id": "httpbin.org",
      "created_at": "2026-09-23T19:18:10Z",
      "current_revision_id": "20308cb1-ed0a-4a30-9c9f-719a70850435",
      "description": null,
      "display_name": null,
      "host": "httpbin.org",
      "name": "httpbin-org",
      "operation_count": 78,
      "origin": "catalog",
      "security_schemes": [],
      "source_url": "https://raw.githubusercontent.com/jentic/jentic-public-apis/refs/heads/main/apis/openapi/httpbin.org/main/0.9.2/openapi.json",
      "update_available": false,
      "updated_at": "2026-09-23T19:18:10Z",
      "vendor": "httpbin-org",
      "version": "0.9.2"
    }
  ],
  "has_more": false,
  "next_cursor": null
}
```

### Search for an API operation

Find an operation by the words it is described with, such as 'create invoice', across every API imported into Jentic One. Each result names its method and address and is ready to pass to 'Call an API operation'.

**Inputs**

- Search for (`query`, text, required): A few words the operation's name or description contains, such as 'send message' or 'list customers'. Jentic can require every word to match, so fewer words find more.
- Only these APIs (`apis`, list): Search only these imported APIs. Leave empty to search all of them.
- At most (`limit`, number): The most operations to return. From 1 to 100. Default: `10`.
- Continue from (`cursor`, text): The previous step's 'next_cursor', to get the next page.

**Outputs**

- `has_more` (true/false): Whether more results follow this page.
- `next_cursor` (text): Pass this as 'Continue from' in the same step to get the next page.
- `operation_count` (number): How many came back.
- `operations` (list): The matching operations, best first.
- `query` (text): What was searched for.

**Example output**

```json
{
  "has_more": false,
  "next_cursor": null,
  "operation_count": 1,
  "operations": [
    {
      "api": {
        "api_id": "httpbin-org/httpbin-org/0.9.2",
        "host": "httpbin.org",
        "name": "httpbin-org",
        "vendor": "httpbin-org",
        "version": "0.9.2"
      },
      "description": null,
      "method": "GET",
      "name": "The request's query parameters.",
      "operation": "GET https://httpbin.org/get",
      "operation_id": "op_cfd40be31965a3a20ec40bae1261d9569ad00673",
      "relevance_score": 2.1e-06,
      "url": "https://httpbin.org/get"
    }
  ],
  "query": "query parameters"
}
```

### Search the API catalog

Search Jentic's public catalog of several thousand APIs for one to import, such as 'stripe' or 'weather'. Shows whether each is imported already and whether a newer description is available.

**Inputs**

- Search for (`query`, text): An API's name or domain, such as stripe or googleapis.com. Leave empty to browse.
- Show (`show`, text): Which APIs to show. Every API if unset. One of: `all` (Every API), `not_imported` (Only APIs not imported yet), `imported` (Only APIs already imported). Default: `all`.
- At most (`limit`, number): The most APIs to return. From 1 to 200. Default: `20`.
- Continue from (`cursor`, text): The previous step's 'next_cursor', to get the next page.

**Outputs**

- `api_count` (number): How many came back.
- `apis` (list): The matching catalog entries.
- `catalog_total` (number): How many APIs the whole catalog holds.
- `has_more` (true/false): Whether more results follow this page.
- `imported_total` (number): How many of those are imported into this instance.
- `next_cursor` (text): Pass this as 'Continue from' in the same step to get the next page.
- `query` (text): What was searched for.

**Example output**

```json
{
  "api_count": 1,
  "apis": [
    {
      "api_id": "httpbin.org",
      "github_url": "https://github.com/jentic/jentic-public-apis/tree/main/apis/openapi/httpbin.org/main",
      "imported": true,
      "spec_url": "https://raw.githubusercontent.com/jentic/jentic-public-apis/refs/heads/main/apis/openapi/httpbin.org/main/0.9.2/openapi.json",
      "update_available": false,
      "vendor": "httpbin.org"
    }
  ],
  "catalog_total": 6147,
  "has_more": false,
  "imported_total": 1,
  "next_cursor": null,
  "query": "httpbin"
}
```