List engines

Lists every engine web search can run and how the platform runs it.

GET /v1/websearch/engines

Websearch → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/websearch/engines`
Method	`GET`
Operation	`list_search_engines`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Lists every engine web search can run and how the platform runs it.

For each engine: whether it is enabled and its place in the run order, whether it takes an API key and whether it needs one, whether the platform holds that key (keyed — the key itself is never returned), whether it answers from this cluster as things stand (available), the option values it is asked with and the options it supports with their bounds. Enabled engines come first, in the order they run.

saved is false when no setting is stored, and the engines shown enabled are then the default: Mojeek alone when its key is held, otherwise bing, ddg and Mojeek — Mojeek's keyless page does not answer from this cluster on its own.

SuperAdmin only. 503 when the settings store or KMS cannot answer: a board that guessed would show an operator a configuration nobody saved.

Request

GET /v1/websearch/engines takes no parameters and no body — the credential is the whole request.

Response

Status	Body	Meaning
`200`	websearch.searchEngines	ok
`default`	problem-details	refused

200 body — 19 fields.

Field	In	Type	Always	Description
`engines`	body	websearch.searchEngine[]	—	Engines are the enabled engines in the order they run, then the rest by name.
`engines[].acceptsKey`	body	boolean	—	AcceptsKey is whether the engine takes an API key at all.
`engines[].available`	body	boolean	—	Available is whether the engine answers from this cluster as things stand: it needs no key there (bing, ddg), or its key is held.
`engines[].enabled`	body	boolean	—	Enabled is whether searches run it.
`engines[].keyed`	body	boolean	—	Keyed is whether the platform holds a key for it in KMS.
`engines[].name`	body	string	—	Name is the engine: `mojeek`, `bing`, `brave` or `ddg`.
`engines[].needsKey`	body	boolean	—	NeedsKey is whether the engine answers only with a key.
`engines[].options`	body	websearch.searchEngineOptions	—
`engines[].options.count`	body	integer (int64)	—	Count is how many hits the engine is asked for per search.
`engines[].options.language`	body	string	—	Language is the default language the engine is asked in, as a tag like `en` or `en-US`.
`engines[].options.region`	body	string	—	Region is a two-letter country code the engine favours, like `GB`.
`engines[].order`	body	integer (int64)	—	Order is its place among the enabled engines, from 1; 0 when disabled.
`engines[].supports`	body	websearch.searchEngineOption[]	—	Supports lists the options the engine reads, with each one's bounds.
`engines[].supports[].default`	body	integer (int64)	—	Default is the count used when none is set.
`engines[].supports[].max`	body	integer (int64)	—	Max is the most count the engine accepts.
`engines[].supports[].min`	body	integer (int64)	—	Min is the least count the engine accepts.
`engines[].supports[].name`	body	string	—	Name is the option: `count`, `language` or `region`.
`engines[].supports[].param`	body	string	—	Param is the engine's own query parameter the option sets, such as `t` or `rb` for Mojeek.
`saved`	body	boolean	—	Saved is whether a setting is stored.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo websearch engines list

.ts

.py

.go

.rs

.java

import { Configuration, WebsearchApi } from 'hanzoai';

const api = new WebsearchApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.listSearchEngines();

from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import WebsearchApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = WebsearchApi(client).list_search_engines()

cfg := hanzoai.NewConfiguration()
cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
client := hanzoai.NewAPIClient(cfg)

resp, _, err := client.WebsearchAPI.ListSearchEngines(context.Background()).Execute()
if err != nil {
	return err
}

use hanzo_client::apis::{configuration::Configuration, websearch_api};

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok();

let result = websearch_api::list_search_engines(&cfg, Default::default()).await?;

import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.WebsearchApi;

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new WebsearchApi(client).listSearchEngines();

curl https://api.hanzo.ai/v1/websearch/engines \
  -H "Authorization: Bearer $HANZO_API_KEY"

Tool websearch, op list_search_engines — POST the JSON-RPC envelope to https://api.hanzo.ai/v1/mcp.

curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "websearch",
         "arguments": {
           "op": "list_search_engines",
           "input": {}
         }
       }
     }'

Websearch API · All Hanzo APIs · Interactive reference

Was this page useful?

Broken link or missing step? Drop it in #docs on Discord or open a PR.

PreviousSearch websearch — GET /v1/websearch/search NextSearch websearch — PATCH /v1/websearch/search