> This page is for Direct Executions.

> 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 of the environment you asked for that have a published release, are deployed, and are neither locked nor withdrawn.

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

**One environment per answer.** `environment` chooses which engines to list — `production`, the real institutions, or `sandbox`, demo engines that answer with test data — and it defaults to your application's. A production application lists its production engines, and may ask for the sandbox ones to rehearse with: a run against a sandbox engine is flagged sandbox. A sandbox application lists sandbox engines only; asking it for `production` answers `403 production_not_enabled_for_this_app`. The two are never listed together.

**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=true` keeps the engines answering right now and `false` the ones that are not; left out, both are listed.

**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/direct-executions/api-reference/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, default)
- `https://clients.infonite.io/api` (Production)

## 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
- `environment` (enum, optional) — The environment to list: `production` (real institutions) or `sandbox` (demo engines that answer with test data). Absent: your application's. A production application may list the sandbox engines it can rehearse with; a sandbox application lists sandbox engines only
  - Allowed values: `sandbox`, `production`

## Response

### 200

**200 OK****Everything your application can execute right now in one environment**, and nothing else. An engine appears here only if it is published, deployed, not locked, not archived and of the environment you asked for — the same rules that decide whether an execution is accepted, so a listed engine is a runnable engine. Production and sandbox engines are never listed together. `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 MarketPlaceEngineSchema`

## Errors

### 403 Forbidden Error

**403 Forbidden****Your application may not list that environment.** A sandbox application lists sandbox engines only.

- `detail` (string, required) — Error message

### 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 ValidationError, required)

## Types

### MarketPlaceEngineSchema

Model with the information of an engine, an engine can be interpreted as a source of information. Each engine is identified by a unique code and an alternative and implements various features for different purposes, such as data retrieval, data enrichment, data validation, etc. Engines contain categories and subcategories that help to identify the general purpose of the engine. You can also use the market to which the engine is oriented, the status of the engine, and the environments in which the engine is available. Engines can only be executed by client applications that have been granted access to them and that are compatible with the engine's environments.

- `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 official 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` (ThemeColorSetSchema, required) — Primary theme 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 MarketPlaceEngineSchemaSubCategoriesItems, 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` (LiveObjectSchema, required) — Information about the availability of the engine
- `is_online` (boolean, required) — Indicate if the engine is online
- `website` (string, optional, nullable)
- `tokenized_access` (boolean, optional, default: false) — Whether this engine can keep your customer's credentials for **recurring access**: launched with `tokenized_access`, it hands you a ticket to exchange for a token, and later runs use the token instead of the password. Typically offered by banks, telcos and utilities — sources worth reading again —, never assumed: check it per engine.

### ValidationError

- `loc` (list of ValidationErrorLocItems, required)
- `msg` (string, required)
- `type` (string, required)
- `input` (any, optional)
- `ctx` (ValidationErrorCtx, optional)

### ThemeColorSetSchema

- `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

### MarketPlaceEngineSchemaSubCategoriesItems

- FinancialType: enum
  - Allowed values: `financial:retail`, `financial:corporate`, `financial:private`, `financial:investment`, `financial:retailer_service`
- PublicType: enum
  - Allowed values: `public:cmf_chile`, `public:afc_chile`, `public:sii_chile`, `public:aeat_spain`, `public:tgss_spain`, `public:sgad_spain`, `public:dgt_spain`, `public:bde_spain`, `public:dian_colombia`
- CommercialType: enum
  - Allowed values: `commercial:telecom`, `commercial:energy`, `commercial:tech_services`, `commercial:digital_content`, `commercial:retail`, `commercial:ecommerce`, `commercial:logistics`, `commercial:healthcare`, `commercial:hospitality`, `commercial:construction`, `commercial:manufacturing`
- OtherType: enum
  - Allowed values: `other:other`

### LiveObjectSchema

Properties for objects whit ping behavior, defines a last ping date

- `last_ping_date` (string, optional, nullable) — Last seen date

### ValidationErrorLocItems

- string
- integer

### ValidationErrorCtx

## 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()
```