> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tako.com/llms.txt
> Use this file to discover all available pages before exploring further.

# List monitor types

> Every monitor type you can create, with the JSON Schema its parameters must satisfy

export const MonitorsExperimental = () => <Warning>
    <strong>Monitors is experimental.</strong> Request and payload shapes can change without a deprecation window. Monitors isn't recommended for production workflows.
  </Warning>;

<MonitorsExperimental />

## Notes

* To authenticate, you'll need a [Tako API key](https://tako.com/console/api-keys). It's best practice to store it as an environment variable to avoid hardcoding sensitive credentials in your code.
* Start here. Tako validates a monitor's `parameters` against its type's schema, so read the type before you call [Create a monitor](/api-reference/monitors-create). This response is the authoritative list, and a type added since this page was written appears only in the response.
* Each item returns `parameters_schema`, the JSON Schema that `parameters` must satisfy; `description`, what the type watches and when it fires; `lookback_seconds`, how far back an occurrence may have happened and still fire; `subject_schema`, the shape of the resolved subject the type returns; and `fire_once_only`.
* `firing_enabled` reports whether this environment evaluates monitors. While it's `false`, [Create a monitor](/api-reference/monitors-create) still accepts a monitor and the monitor stays `active`, but nothing evaluates it and nothing fires.

## The registered types

Type names are namespaced `domain.subtype`.

| Type | Fires when |
| - | - |
| `stocks.pct_change` | A stock's move over your `window` reaches `threshold` percent in `direction`. Tako measures the move from the reference close at the start of the window, not from the price when you created the monitor. |
| `stocks.crosses` | A stock's price closes on the far side of your `level` from the prior session's close. A close that lands exactly on the level hasn't passed it. |
| `stocks.new_52w_extreme` | A stock passes the highest or lowest daily close of the 365 days before the current session, in `direction`. The price has to pass the extreme; matching it doesn't fire. |
| `crypto.crosses` | A crypto asset's price in USD reaches your `level` in `direction`. It fires once. If the latest snapshot has already reached the level, the create fails, so the monitor always arms on the near side. |
| `forex.crosses` | A currency pair's rate reaches your `level` in `direction`. The level is in the quote currency per one unit of the base, so a EUR/USD level of 1.15 is 1.15 US dollars per euro. Tako compares against the closing mid-rate, and the feed runs up to 30 minutes behind. It fires once. If the rate has already reached the level, the create fails. |
| `sports.game_start` | A game starts, the first time the feed reports it in play. Tako stamps the firing at the scheduled start, so a monitor you create after that time never fires for that game, even when the real start was delayed. |
| `sports.game_result` | A game ends. On a team, it fires only when the result matches your `outcome`, by at least `margin` when you set one. On a whole game, it fires with the winner and accepts neither `outcome` nor `margin`. A tie matches neither outcome. |
| `sports.score_event` | A score rises while a game is live or final. On a team, only that team's scoring fires it. On a whole game, either side's does. NBA teams and games aren't accepted. |
| `sports.odds_crosses` | A game's betting line at the book you choose reaches your `level` in `direction`. |

<Note>
  `stocks.pct_change` and `stocks.new_52w_extreme` are **state alerts**. If you create one while its condition already holds, the next price update fires it. On a delayed feed, that update arrives as late as the feed's delay.
</Note>

## Naming a subject

Each family names its subject a different way.

| Type | Subject fields |
| - | - |
| `stocks.*` | `ticker`, plus `exchange` as an ISO 10383 MIC when the ticker is listed on more than one exchange. |
| `crypto.crosses` | `ticker`, or `coinmarketcap_id` to identify an asset outside the top-ranked set. Tako rejects an asset ranked outside the top 1000. |
| `forex.crosses` | `base` and `quote`, each an ISO 4217 currency code, such as `EUR` and `USD`. |
| `sports.game_start`, `sports.game_result`, `sports.score_event` | `game_id`, `team_id`, or both. |
| `sports.odds_crosses` | `game_id` and `team_id`, both required. |

For the three team types, the two ids combine:

* `game_id` alone watches the whole game, and a firing reports both sides.
* `team_id` alone follows that team's games as they come.
* Both together watch that team's side of that one game.

Both ids come from [List sports games](/api-reference/sports-games): a row's `id` is the game id, and its `home.id` and `away.id` are team ids.

## What a firing sends

Each type sends its own set of `payload` fields to your notification channels. For the fields, see [Webhook deliveries](/documentation/integrating-tako/monitors/webhook-deliveries#payload-fields-by-monitor-type).


## OpenAPI

````yaml GET /v1/monitor_types
openapi: 3.1.0
info:
  title: Knowledge Search API
  version: 1.0.0
servers:
  - url: https://tako.com/api/
    description: Tako Production API Server
security: []
paths:
  /v1/monitor_types:
    get:
      tags:
        - monitors
      summary: List monitor types
      description: >-
        Every registered monitor type, with the JSON Schema that its parameters
        must satisfy. Each type's description says what it watches and when it
        fires. stocks.pct_change and stocks.new_52w_extreme are state alerts. If
        you create one while its condition already holds, it fires on the first
        trading session that closes after you create it.


        **Experimental.** Request and payload shapes can change without a
        deprecation window. Monitors isn't recommended for production workflows.
      operationId: listMonitorTypes
      responses:
        '200':
          description: Every registered monitor type
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MonitorTypeList'
        '401':
          description: Missing or invalid API key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BaseAPIError'
      security:
        - apiKey: []
components:
  schemas:
    MonitorTypeList:
      properties:
        items:
          items:
            $ref: '#/components/schemas/MonitorTypeInfo'
          type: array
          title: Items
        firing_enabled:
          type: boolean
          title: Firing Enabled
          description: >-
            Whether this environment evaluates monitors. While it's false,
            createMonitor still accepts a monitor and the monitor stays active,
            but nothing evaluates it and it reports no firings.
      type: object
      required:
        - items
        - firing_enabled
      title: MonitorTypeList
    BaseAPIError:
      properties:
        error_message:
          type: string
          title: Error Message
        error_type:
          $ref: '#/components/schemas/APIErrorType'
      type: object
      required:
        - error_message
        - error_type
      title: BaseAPIError
    MonitorTypeInfo:
      properties:
        name:
          type: string
          title: Name
        description:
          type: string
          title: Description
          description: What the type watches and when it fires.
        parameters_schema:
          additionalProperties: true
          type: object
          title: Parameters Schema
          description: JSON Schema for the parameters createMonitor accepts.
        lookback_seconds:
          type: integer
          title: Lookback Seconds
          description: How far back an occurrence may have happened and still fire.
        fire_once_only:
          type: boolean
          title: Fire Once Only
          description: >-
            Whether this type reports an occurrence that stays true once it
            happens. When it's true, createMonitor accepts only fire_once=true.
        subject_schema:
          anyOf:
            - additionalProperties: true
              type: object
            - type: 'null'
          title: Subject Schema
          description: >-
            JSON Schema for the resolved subject this type returns, and for each
            entry in candidates.
      type: object
      required:
        - name
        - description
        - parameters_schema
        - lookback_seconds
        - fire_once_only
      title: MonitorTypeInfo
    APIErrorType:
      type: string
      enum:
        - BAD_REQUEST
        - AUTHENTICATION_ERROR
        - INTERNAL_SERVER_ERROR
        - RELEVANT_RESULTS_NOT_FOUND
        - RATE_LIMIT_EXCEEDED
        - PAYMENT_REQUIRED
        - REQUEST_TIMEOUT
        - FORBIDDEN
        - NOT_FOUND
        - SERVICE_UNAVAILABLE
        - SERVICE_OVERLOADED
        - UNSUPPORTED_CONTENT_FORMAT
        - PLACEHOLDER_CARD
        - VARIABLE_COST_NOT_REQUESTED
      title: APIErrorType
  securitySchemes:
    apiKey:
      type: apiKey
      name: X-API-Key
      in: header

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.