> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://infonite.dev/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://infonite.dev/_mcp/server.

# List your engines

GET https://clients.infonite.tech/api/config/engines/list

List the engines your application can run right now.

An engine is one source — a bank, a utility, a public administration — behind one access channel. Everything you can execute is in this list, and everything in this list is executable at the moment you asked: the response only contains engines that are enabled for your company and application, available in your application's environment, have a published release, and are online.

Use `reference` from each entry wherever an `engine_reference` is asked for.

**Filtering.** `markets` narrows by country, `main_category` by the kind of source, and `features` by what you need to retrieve — with `features_mode=and` (the default) an engine must offer all of them, with `or` any of them. `is_online` is there for completeness; leaving it out already gives you the live ones.

**What to do with `is_online: false`.** It means the engine is not answering right now, usually because the source itself is unavailable. It is a temporary condition: an execution against it is rejected with `503`, and the engine comes back on its own.

**Cache this response. It is a directory, not a live signal.** It changes when an engine is added or retired, not from one minute to the next, so fetch it on a schedule — once or twice a day is plenty — and launch your executions against your own copy. Refreshing it periodically is still worth doing: that is how a new engine, or a changed login form, reaches you without a deploy. Rate limits here are not aggressive today and we would rather keep it that way, so we reserve the right to tighten them; the integrations that get tightened are the ones polling a directory in a loop.

> This endpoint needs to be executed with an app secret, so should always be used in server side without exposing the secret to customers.


Reference: https://infonite.dev/api-reference/direct-executions/direct-executions-api/engines/direct-executions-v-1-engines-list

## Authentication

- `X-APP-SECRET` header (required) — Application Secret

## Servers

- `https://clients.infonite.tech/api` (Legacy Server, default)
- `https://clients.infonite.io/api` (Production Server)

## Request

### Query parameters

- `markets` (list of string, optional) — Filter by markets, if multiple values are provided, the result will be the engines that match any of the markets. If no value is provided, all markets will be returned
- `features` (list of enum, optional) — Filter by features. use with `features_mode` to specify how to filter the features
  - Allowed values: `accounts_read`, `cards_read`, `deposits_read`, `loans_read`, `credits_read`, `investment_accounts_read`, `funds_read`, `stocks_read`, `pensions_read`, `accounts_certificates`, `direct_debits_read`, `customer_information_read`, `source_contracts_read`, `cloud_resource_read`, `supplier_invoices_read`, `client_invoices_read`, `labor_check`, `public_pensions`, `public_document_verification`, `yearly_individual_tax`, `vehicles_data`, `driver_data`, `academic_data`, `properties_data`, `credit_registry_data`
- `features_mode` (enum, optional, default: and) — Mode to filter the features, `or` will return engines that match any of the features, `and` will return engines that match all the features
  - Allowed values: `and`, `or`
- `main_category` (enum, optional) — Filter by engine main category. If not informed, all categories will be returned
  - Allowed values: `financial`, `public`, `commercial`, `cloud`, `other`
- `is_online` (boolean, optional) — If specified, filter by online/offline. If not specified, all items will be returned

## Response

### 200

**200 OK****Everything your application can execute right now**, and nothing else. An engine appears here only if it is published, deployed, not locked, not archived, granted to your company and compatible with your application's environment — the same rules that decide whether an execution is accepted, so a listed engine is a runnable engine. `reference` is the value to send as `engine_reference` when you start an execution. An empty list is an answer — your application has nothing enabled with those filters — not an error.

- `list of object`
  - `reference` (string, required)
  - `engine_code` (string, required) — Engine Code
  - `engine_alternative` (enum, required) — Engines can have multiple alternatives, each alternative is a different implementation for the same provider, but using a different platform or technology. For example there can be two alternatives for a financial institution, one for a website and another for the mobile app of the same institution. Note that two alternatives of the same engine can retrieve different information, based on the availability of the information in the platform or technology used by the alternative. Allowed values are: - `website`: Alternative for website source - `mobile`: Alternative for mobile source - `api`: Alternative for oficial api source - `other`: Alternative for custom implementation
    - Allowed values: `website`, `mobile`, `api`, `other`
  - `engine_version` (string, required)
  - `environment` (enum, required)
    - Allowed values: `sandbox`, `production`
  - `status` (enum, required)
    - Allowed values: `draft`, `implementing`, `published`, `partial`, `maintenance`
  - `priority` (integer, required) — Priority of the engine (For ordering purposes)
  - `keywords` (list of string, required) — Keywords that can be used to search
  - `color_primary` (object, required) — Primary theme color
    - `lighter` (string, required) — Lighter color
    - `light` (string, required) — Light color
    - `main` (string, required) — Main color
    - `dark` (string, required) — Dark color
    - `darker` (string, required) — Darker color
    - `contrast_text` (string, required) — Contrast text color
    - `contrastText` (string, required) — Contrast text color
  - `main_category` (enum, required) — Main Category of the engine normally related to the actions that the engine can performon the provider source or the kind of information that the engine can retrieve
    - Allowed values: `financial`, `public`, `commercial`, `cloud`, `other`
  - `sub_categories` (list of enum or enum or enum or enum, required) — Sub Categories of the engine normally based on the kind of actions that the engine can perform on the provider source or the kind of information that the engine can retrieve
  - `name` (string, required) — Formal name of the engine
  - `description` (string, required) — Brief description of the engine
  - `markets` (list of string, required) — Markets where the engine is oriented, can be used to filter the target audience of the engine
  - `languages` (list of string, required) — Languages supported by the provider
  - `engine_restrictions` (list of string, required) — Known engine restrictions
  - `engine_issues` (list of string, required) — Known engine issues
  - `action_required_frequency` (enum, required)
    - Allowed values: `unknown`, `never`, `on_first_use`, `rarely`, `often`, `always`
  - `features` (list of enum, required) — List of features that the engine allows. Each feature is a type of action that the engine can perform
    - Allowed values: `accounts_read`, `cards_read`, `deposits_read`, `loans_read`, `credits_read`, `investment_accounts_read`, `funds_read`, `stocks_read`, `pensions_read`, `accounts_certificates`, `direct_debits_read`, `customer_information_read`, `source_contracts_read`, `cloud_resource_read`, `supplier_invoices_read`, `client_invoices_read`, `labor_check`, `public_pensions`, `public_document_verification`, `yearly_individual_tax`, `vehicles_data`, `driver_data`, `academic_data`, `properties_data`, `credit_registry_data`
  - `live` (object, required) — Information about the availability of the engine
    - `last_ping_date` (string, optional, nullable) — Last seen date
  - `is_online` (boolean, required) — Indicate if the engine is online
  - `website` (string, optional, nullable)

## Errors

### 422 Unprocessable Entity Error

**422 Unprocessable Content**A filter carried a value that is not in its vocabulary. **`detail` is a LIST**, one entry per rejected value: it names the parameter and lists what it accepts.

- `detail` (list of object, required)
  - `loc` (list of string or integer, required)
  - `msg` (string, required)
  - `type` (string, required)
  - `input` (any, optional)
  - `ctx` (object, optional)

## Examples

**Response**

```json
[
  {
    "reference": "DEMOBANKXXXXFIN100ES9999-mobile",
    "engine_code": "DEMOBANKXXXXFIN100ES9999",
    "engine_alternative": "mobile",
    "engine_version": "2026.8.100",
    "environment": "sandbox",
    "status": "published",
    "priority": 0,
    "keywords": [],
    "color_primary": {
      "lighter": "#49535d",
      "light": "#1f2933",
      "main": "#1c252e",
      "dark": "#141a20",
      "darker": "#0e1217",
      "contrast_text": "#ffffff",
      "contrastText": "#ffffff"
    },
    "main_category": "financial",
    "sub_categories": [
      "financial:retail",
      "financial:investment"
    ],
    "name": "Demo Bank",
    "description": "FAKE BANK FOR TESTING",
    "markets": [
      "ES",
      "FR",
      "GB",
      "GR"
    ],
    "languages": [
      "spa",
      "eng"
    ],
    "engine_restrictions": [],
    "engine_issues": [],
    "action_required_frequency": "unknown",
    "features": [
      "accounts_read",
      "cards_read",
      "deposits_read",
      "loans_read",
      "investment_accounts_read",
      "stocks_read",
      "funds_read",
      "pensions_read",
      "customer_information_read"
    ],
    "live": {
      "last_ping_date": "2026-09-12T10:15:30+00:00"
    },
    "is_online": true,
    "website": "https://demobank.infonite.tech/"
  },
  {
    "reference": "TGSSXSBXXXXXPUB254ESXXXX-api",
    "engine_code": "TGSSXSBXXXXXPUB254ESXXXX",
    "engine_alternative": "api",
    "engine_version": "2026.7.2401",
    "environment": "sandbox",
    "status": "published",
    "priority": 0,
    "keywords": [],
    "color_primary": {
      "lighter": "#49535d",
      "light": "#1f2933",
      "main": "#1c252e",
      "dark": "#141a20",
      "darker": "#0e1217",
      "contrast_text": "#ffffff",
      "contrastText": "#ffffff"
    },
    "main_category": "public",
    "sub_categories": [
      "public:tgss_spain"
    ],
    "name": "TGSS - Sandbox",
    "description": "TGSS Mock for Spain",
    "markets": [
      "ES"
    ],
    "languages": [
      "spa"
    ],
    "engine_restrictions": [],
    "engine_issues": [],
    "action_required_frequency": "unknown",
    "features": [
      "customer_information_read",
      "labor_check",
      "public_pensions",
      "vehicles_data",
      "driver_data",
      "credit_registry_data"
    ],
    "live": {
      "last_ping_date": "2026-09-12T10:15:30+00:00"
    },
    "is_online": true,
    "website": "https://tgss-sandbox.infonite.tech/"
  }
]
```

**SDK Code**

```python A sandbox application with two engines
import requests

url = "https://clients.infonite.tech/api/config/engines/list"

headers = {"X-APP-SECRET": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript A sandbox application with two engines
const url = 'https://clients.infonite.tech/api/config/engines/list';
const options = {method: 'GET', headers: {'X-APP-SECRET': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go A sandbox application with two engines
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://clients.infonite.tech/api/config/engines/list"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("X-APP-SECRET", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby A sandbox application with two engines
require 'uri'
require 'net/http'

url = URI("https://clients.infonite.tech/api/config/engines/list")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["X-APP-SECRET"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java A sandbox application with two engines
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://clients.infonite.tech/api/config/engines/list")
  .header("X-APP-SECRET", "<apiKey>")
  .asString();
```

```php A sandbox application with two engines
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://clients.infonite.tech/api/config/engines/list', [
  'headers' => [
    'X-APP-SECRET' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp A sandbox application with two engines
using RestSharp;

var client = new RestClient("https://clients.infonite.tech/api/config/engines/list");
var request = new RestRequest(Method.GET);
request.AddHeader("X-APP-SECRET", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift A sandbox application with two engines
import Foundation

let headers = ["X-APP-SECRET": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://clients.infonite.tech/api/config/engines/list")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```