# Get automation (https://docs.capy.ai/api-reference/automations/get-automation)

`GET https://api.capy.ai/api/v1/automations/{automationId}`

## Authorization

Send an API key as a bearer token: `Authorization: Bearer $CAPY_API_KEY`. See https://docs.capy.ai/api-reference/authentication.md.

## Parameters

| Name | In | Type | Required | Description |
| --- | --- | --- | --- | --- |
| `automationId` | path | string | yes |  |

## Responses

- `200` Automation: `AutomationEncoded`
- `401` capy/Unauthorized: `capy_UnauthorizedEncoded`
- `403` capy/Forbidden: `capy_ForbiddenEncoded`
- `404` capy/AutomationNotFound: `capy_AutomationNotFoundEncoded`
- `429` capy/RateLimited: `capy_RateLimitedEncoded`

## Example

```bash
curl -X GET "https://api.capy.ai/api/v1/automations/{automationId}" \
  -H "Authorization: Bearer $CAPY_API_KEY"
```

## Referenced schemas

```json
{
  "AutomationEncoded": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      },
      "projectId": {
        "type": "string"
      },
      "name": {
        "type": "string"
      },
      "description": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ]
      },
      "prompt": {
        "type": "string"
      },
      "triggers": {
        "type": "array",
        "items": {
          "anyOf": [
            {
              "type": "object",
              "properties": {
                "type": {
                  "type": "string",
                  "enum": [
                    "schedule"
                  ]
                },
                "cron": {
                  "type": "string",
                  "minLength": 1,
                  "description": "Five-field cron expression, e.g. `0 9 * * *` for daily at 09:00."
                },
                "timezone": {
                  "type": "string",
                  "minLength": 1,
                  "description": "IANA timezone for the schedule, e.g. `America/New_York`."
                }
              },
              "required": [
                "type",
                "cron",
                "timezone"
              ],
              "additionalProperties": false
            },
            {
              "type": "object",
              "properties": {
                "type": {
                  "type": "string",
                  "enum": [
                    "github"
                  ]
                },
                "event": {
                  "type": "string",
                  "enum": [
                    "draft_opened",
                    "pull_request_opened",
                    "pull_request_pushed",
                    "pull_request_merged",
                    "comment",
                    "branch_push",
                    "label_change",
                    "checks",
                    "issue_comment",
                    "pull_request_review_comment",
                    "pull_request_review_submitted",
                    "pull_request_review_thread",
                    "workflow_run"
                  ],
                  "description": "The GitHub event that starts a run."
                },
                "conditions": {
                  "type": "object",
                  "properties": {
                    "repositories": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Full repository names to match, e.g. owner/repo."
                    },
                    "branches": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Branch names to match: a pull request's base branch, or the branch of a push, check, or workflow run."
                    },
                    "head_branches": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Head branch names to match: a pull request's head branch, or the branch a check or workflow run ran on."
                    },
                    "authors": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "GitHub login names of the author of the pull request or issue the event is on, not the commenter or reviewer (use actors for those)."
                    },
                    "labels": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Match when any of these labels is present; on label_change, the label that was added or removed."
                    },
                    "states": {
                      "type": "array",
                      "items": {
                        "type": "string",
                        "enum": [
                          "open",
                          "draft",
                          "closed",
                          "merged"
                        ]
                      },
                      "description": "Pull request states to match."
                    },
                    "actions": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Raw event action names to match, e.g. opened, closed."
                    },
                    "conclusions": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Check or workflow conclusions to match, e.g. success, failure."
                    },
                    "workflows": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Workflow display names to match (the yml `name`), not file names."
                    },
                    "check_names": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Check run names to match."
                    },
                    "review_states": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Review states to match, e.g. approved, changes_requested."
                    },
                    "actors": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "GitHub login names of the actor that fired the event: the pusher, commenter, reviewer, or merger."
                    }
                  },
                  "additionalProperties": false,
                  "description": "Filters that narrow which GitHub events start a run. A condition matches when the event matches any of its listed values."
                },
                "run_when": {
                  "type": "string",
                  "minLength": 1,
                  "description": "Natural-language gate checked against each event before a run starts; non-matching events are skipped, so keep it to one sentence. To remove the gate, omit this field from the trigger; null is rejected."
                }
              },
              "required": [
                "type",
                "event"
              ],
              "additionalProperties": false
            },
            {
              "type": "object",
              "properties": {
                "type": {
                  "type": "string",
                  "enum": [
                    "slack"
                  ]
                },
                "event": {
                  "type": "string",
                  "enum": [
                    "message",
                    "reaction",
                    "channel_created"
                  ],
                  "description": "The Slack event that starts a run."
                },
                "conditions": {
                  "type": "object",
                  "properties": {
                    "workspaces": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Slack team ids (T...) to match. Not workspace names. A subscription fills in the organization's connected workspace when omitted."
                    },
                    "channels": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Slack channel ids (C...) to match. Not #channel-names."
                    },
                    "threads": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Parent message timestamps to match: only replies in those threads, never a top-level message."
                    },
                    "users": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Slack user ids (U...) to match: the message author on a message trigger, the person who added the reaction on a reaction trigger."
                    },
                    "actors": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Slack user ids (U...) of the actor that fired the event."
                    },
                    "reactions": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Emoji names without colons to match on a reaction trigger, e.g. eyes or firecracker; a custom workspace emoji is its name."
                    },
                    "message_placements": {
                      "type": "array",
                      "items": {
                        "type": "string",
                        "enum": [
                          "top_level",
                          "reply"
                        ]
                      },
                      "description": "Match top-level messages, replies, or both."
                    },
                    "message_types": {
                      "type": "array",
                      "items": {
                        "type": "string",
                        "enum": [
                          "human",
                          "bot"
                        ]
                      },
                      "description": "Match human messages, bot messages, or both."
                    },
                    "include_bots": {
                      "type": "boolean",
                      "description": "Include messages from bots. Defaults to false."
                    },
                    "grouping_window_seconds": {
                      "type": "integer",
                      "minimum": 0,
                      "maximum": 300,
                      "description": "Seconds to group a burst of messages into one run. Defaults to 0 - no grouping, one run per matched message immediately."
                    },
                    "contains": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Run only when the message text contains one of these substrings. At most 20 values of at most 250 characters each."
                    },
                    "excludes": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Skip when the message text contains one of these substrings. At most 20 values of at most 250 characters each."
                    },
                    "regex": {
                      "type": "string",
                      "description": "Run only when the message text matches this RE2 regular expression (no lookaround or backreferences; write \\x{00e9}, not \\u00e9)."
                    }
                  },
                  "additionalProperties": false,
                  "description": "Filters that narrow which Slack events start a run. A condition matches when the event matches any of its listed values."
                },
                "run_when": {
                  "type": "string",
                  "minLength": 1,
                  "description": "Natural-language gate checked against each event before a run starts; non-matching events are skipped, so keep it to one sentence. To remove the gate, omit this field from the trigger; null is rejected."
                },
                "ack_reaction": {
                  "type": "string",
                  "allOf": [
                    {
                      "allOf": [
                        {
                          "minLength": 1
                        },
                        {
                          "maxLength": 64
                        }
                      ],
                      "description": "Emoji name to react with on a top-level triggering message when this trigger matches, e.g. `eyes`. Replies and an absent value post no reaction."
                    }
                  ]
                }
              },
              "required": [
                "type",
                "event"
              ],
              "additionalProperties": false
            },
            {
              "type": "object",
              "properties": {
                "type": {
                  "type": "string",
                  "enum": [
                    "sentry"
                  ]
                },
                "event": {
                  "type": "string",
                  "enum": [
                    "issue_lifecycle",
                    "any_issue",
                    "event_alert"
                  ],
                  "description": "The Sentry event that starts a run."
                },
                "conditions": {
                  "type": "object",
                  "properties": {
                    "projects": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Sentry project slugs or ids to match."
                    },
                    "levels": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Issue levels to match, e.g. error, warning."
                    },
                    "actions": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Raw event action names to match."
                    }
                  },
                  "additionalProperties": false,
                  "description": "Filters that narrow which Sentry events start a run. A condition matches when the event matches any of its listed values."
                },
                "run_when": {
                  "type": "string",
                  "minLength": 1,
                  "description": "Natural-language gate checked against each event before a run starts; non-matching events are skipped, so keep it to one sentence. To remove the gate, omit this field from the trigger; null is rejected."
                }
              },
              "required": [
                "type",
                "event"
              ],
              "additionalProperties": false
            },
            {
              "type": "object",
              "properties": {
                "type": {
                  "type": "string",
                  "enum": [
                    "linear"
                  ]
                },
                "event": {
                  "type": "string",
                  "enum": [
                    "issue_created",
                    "status_changed",
                    "end_cycle"
                  ],
                  "description": "The Linear event that starts a run."
                },
                "conditions": {
                  "type": "object",
                  "properties": {
                    "workspaces": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Linear workspace ids to match."
                    },
                    "teams": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Linear team ids or keys to match."
                    },
                    "projects": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Linear project ids to match."
                    },
                    "statuses": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Issue statuses to match after the change."
                    },
                    "from_statuses": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Issue statuses to match before the change."
                    },
                    "status_transitions": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Status transitions to match, e.g. Todo->In Progress."
                    },
                    "priorities": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Issue priorities to match."
                    },
                    "actors": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Linear user ids of the actor that fired the event."
                    },
                    "labels": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Match when any of these labels is present."
                    },
                    "assignees": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Linear user ids of the assignee to match."
                    },
                    "cycles": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Linear cycle ids to match."
                    }
                  },
                  "additionalProperties": false,
                  "description": "Filters that narrow which Linear events start a run. A condition matches when the event matches any of its listed values."
                },
                "run_when": {
                  "type": "string",
                  "minLength": 1,
                  "description": "Natural-language gate checked against each event before a run starts; non-matching events are skipped, so keep it to one sentence. To remove the gate, omit this field from the trigger; null is rejected."
                }
              },
              "required": [
                "type",
                "event"
              ],
              "additionalProperties": false
            },
            {
              "type": "object",
              "properties": {
                "type": {
                  "type": "string",
                  "enum": [
                    "incoming_webhook"
                  ]
                },
                "coalescing": {
                  "$ref": "#/components/schemas/WebhookCoalescing"
                },
                "conditions": {
                  "type": "object",
                  "properties": {
                    "contains": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Run only when the request body contains one of these substrings. At most 20 values of at most 250 characters each."
                    },
                    "excludes": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "Skip when the request body contains one of these substrings. At most 20 values of at most 250 characters each."
                    },
                    "regex": {
                      "type": "string",
                      "description": "Run only when the request body matches this RE2 regular expression (no lookaround or backreferences; write \\x{00e9}, not \\u00e9)."
                    }
                  },
                  "additionalProperties": false,
                  "description": "Filters that narrow which incoming requests start a run. A condition matches when the request matches any of its listed values."
                },
                "run_when": {
                  "type": "string",
                  "minLength": 1,
                  "description": "Natural-language gate checked against each event before a run starts; non-matching events are skipped, so keep it to one sentence. To remove the gate, omit this field from the trigger; null is rejected."
                }
              },
              "required": [
                "type"
              ],
              "additionalProperties": false
            },
            {
              "type": "object",
              "properties": {
                "type": {
                  "type": "string",
                  "enum": [
                    "on_demand"
                  ]
                }
              },
              "required": [
                "type"
              ],
              "additionalProperties": false
            }
          ]
        }
      },
      "model": {
        "anyOf": [
          {
            "$ref": "#/components/schemas/ModelSelection"
          },
          {
            "type": "null"
          }
        ],
        "description": "The pinned model, or null when the automation is unpinned and each run resolves the run-as principal's default model at run creation."
      },
      "repos": {
        "type": "array",
        "items": {
          "type": "object",
          "properties": {
            "repo": {
              "type": "string"
            },
            "branch": {
              "type": "string"
            }
          },
          "required": [
            "repo",
            "branch"
          ],
          "additionalProperties": false
        }
      },
      "threadMode": {
        "type": "string",
        "enum": [
          "new",
          "single"
        ]
      },
      "slackImpersonation": {
        "type": "boolean"
      },
      "quietSlackPosts": {
        "type": "boolean"
      },
      "singleJamId": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ]
      },
      "mcpOverrides": {
        "anyOf": [
          {
            "type": "object",
            "properties": {
              "enabled_server_keys": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "External MCP server keys to enable for this automation's runs, beyond the project defaults. A key may not appear in both lists."
              },
              "disabled_server_keys": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "External MCP server keys to disable for this automation's runs."
              }
            },
            "additionalProperties": false
          },
          {
            "type": "null"
          }
        ]
      },
      "maxRunsPerDay": {
        "anyOf": [
          {
            "type": "integer"
          },
          {
            "type": "null"
          }
        ]
      },
      "machineSize": {
        "anyOf": [
          {
            "type": "string",
            "enum": [
              "small",
              "medium",
              "large",
              "ultra",
              "hyper",
              "bigguy"
            ]
          },
          {
            "type": "null"
          }
        ]
      },
      "organize": {
        "anyOf": [
          {
            "type": "object",
            "properties": {
              "pin": {
                "type": "boolean"
              },
              "folders": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "tags": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              }
            },
            "additionalProperties": false
          },
          {
            "type": "null"
          }
        ],
        "description": "How each run's thread lands on the board, applied as the run-as principal when the run creates its thread: pinned, filed into folders, tagged. Null organizes nothing."
      },
      "enabled": {
        "type": "boolean"
      },
      "deleted": {
        "type": "boolean"
      },
      "disabledReason": {
        "anyOf": [
          {
            "type": "string",
            "enum": [
              "run_as_unavailable",
              "standing_thread_archived"
            ]
          },
          {
            "type": "null"
          }
        ]
      },
      "runAsKind": {
        "type": "string",
        "enum": [
          "human",
          "service"
        ]
      },
      "runAsId": {
        "type": "string"
      },
      "runCount": {
        "type": "integer"
      },
      "lastTriggeredAt": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ]
      },
      "nextRunAt": {
        "type": "string"
      },
      "createdAt": {
        "type": "string"
      },
      "updatedAt": {
        "type": "string"
      }
    },
    "required": [
      "id",
      "projectId",
      "name",
      "description",
      "prompt",
      "triggers",
      "model",
      "repos",
      "threadMode",
      "slackImpersonation",
      "quietSlackPosts",
      "singleJamId",
      "mcpOverrides",
      "maxRunsPerDay",
      "machineSize",
      "organize",
      "enabled",
      "deleted",
      "disabledReason",
      "runAsKind",
      "runAsId",
      "runCount",
      "lastTriggeredAt",
      "createdAt",
      "updatedAt"
    ],
    "additionalProperties": false
  },
  "WebhookCoalescing": {
    "type": "object",
    "properties": {
      "rules": {
        "type": "array",
        "items": {
          "$ref": "#/components/schemas/WebhookGroupRule"
        },
        "allOf": [
          {
            "allOf": [
              {
                "minItems": 1
              },
              {
                "maxItems": 8
              }
            ],
            "description": "1–8 ordered rules. The first rule whose conditions all hold assigns the delivery's group; groups are scoped per rule. A delivery matching no rule starts its own run immediately."
          }
        ]
      },
      "max_events": {
        "type": "integer",
        "minimum": 2,
        "maximum": 100,
        "description": "Close after this many unique accepted events, from 2 to 100. Required; no default."
      },
      "max_wait_seconds": {
        "type": "integer",
        "minimum": 1,
        "maximum": 3600,
        "description": "Hard deadline from the first event, from 1 to 3600 seconds. Required; later arrivals never extend it."
      },
      "quiet_period_seconds": {
        "type": "integer",
        "minimum": 1,
        "maximum": 3600,
        "description": "Optional idle window after the last unique acceptance, from 1 to 3600 seconds and no greater than maximum wait. Omit to disable idle closing. Duplicates never reset it."
      }
    },
    "required": [
      "rules",
      "max_events",
      "max_wait_seconds"
    ],
    "additionalProperties": false
  },
  "WebhookGroupRule": {
    "type": "object",
    "properties": {
      "when": {
        "type": "array",
        "items": {
          "$ref": "#/components/schemas/WebhookRuleCondition"
        },
        "allOf": [
          {
            "allOf": [
              {
                "minItems": 1
              },
              {
                "maxItems": 4
              }
            ],
            "description": "1–4 conditions that must all hold for this rule to apply. Omit to apply to every delivery."
          }
        ]
      },
      "group_by": {
        "anyOf": [
          {
            "type": "string",
            "enum": [
              "all"
            ]
          },
          {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/WebhookGroupSelector"
            },
            "allOf": [
              {
                "minItems": 1
              },
              {
                "maxItems": 4
              }
            ]
          }
        ],
        "description": "Use all for one pending group under this rule, or 1–4 ordered body/header selectors for a typed tuple key. Only body selectors require JSON; missing or invalid values reject the request rather than sharing a fallback group."
      }
    },
    "required": [
      "group_by"
    ],
    "additionalProperties": false,
    "description": "One grouping rule: optional conditions plus the fields that define a group."
  },
  "WebhookRuleCondition": {
    "anyOf": [
      {
        "type": "object",
        "properties": {
          "body_pointer": {
            "type": "string",
            "maxLength": 1024,
            "pattern": "^(?:\\/(?:[^~/]|~[01])*)*$",
            "description": "Strict RFC6901 JSON pointer into the parsed body, up to 1024 characters. Empty selects the root. The selected value must be a non-null finite scalar of at most 1024 UTF-8 bytes when JSON encoded."
          },
          "equals": {
            "type": "string",
            "maxLength": 1024,
            "description": "Expected value, compared as text: a selected string, number, or boolean matches when its plain text form equals this. A missing or non-scalar value never matches."
          }
        },
        "required": [
          "body_pointer",
          "equals"
        ],
        "additionalProperties": false
      },
      {
        "type": "object",
        "properties": {
          "header": {
            "type": "string",
            "allOf": [
              {
                "minLength": 1
              },
              {
                "maxLength": 128
              }
            ],
            "pattern": "^[!#$%&'*+.^_`|~0-9A-Za-z-]+$"
          },
          "equals": {
            "type": "string",
            "maxLength": 1024,
            "description": "Expected value, compared as text: a selected string, number, or boolean matches when its plain text form equals this. A missing or non-scalar value never matches."
          }
        },
        "required": [
          "header",
          "equals"
        ],
        "additionalProperties": false
      }
    ],
    "description": "A body pointer or request header whose value must equal the expected text."
  },
  "WebhookGroupSelector": {
    "anyOf": [
      {
        "type": "object",
        "properties": {
          "body_pointer": {
            "type": "string",
            "maxLength": 1024,
            "pattern": "^(?:\\/(?:[^~/]|~[01])*)*$",
            "description": "Strict RFC6901 JSON pointer into the parsed body, up to 1024 characters. Empty selects the root. The selected value must be a non-null finite scalar of at most 1024 UTF-8 bytes when JSON encoded."
          }
        },
        "required": [
          "body_pointer"
        ],
        "additionalProperties": false
      },
      {
        "type": "object",
        "properties": {
          "header": {
            "type": "string",
            "allOf": [
              {
                "minLength": 1
              },
              {
                "maxLength": 128
              }
            ],
            "pattern": "^[!#$%&'*+.^_`|~0-9A-Za-z-]+$"
          }
        },
        "required": [
          "header"
        ],
        "additionalProperties": false
      }
    ],
    "description": "One body pointer or request header whose value becomes part of the group key."
  },
  "ModelSelection": {
    "type": "object",
    "properties": {
      "modelId": {
        "type": "string"
      },
      "reasoningMode": {
        "type": "string",
        "enum": [
          "none",
          "instant",
          "minimal",
          "low",
          "medium",
          "high",
          "xhigh",
          "max"
        ]
      },
      "modes": {
        "type": "object",
        "properties": {
          "fast": {
            "type": "boolean"
          },
          "pro": {
            "type": "boolean"
          },
          "ultrafast": {
            "type": "boolean"
          },
          "daybreak": {
            "type": "boolean"
          }
        },
        "additionalProperties": false
      }
    },
    "required": [
      "modelId"
    ],
    "additionalProperties": false
  },
  "capy_UnauthorizedEncoded": {
    "type": "object",
    "properties": {
      "_tag": {
        "type": "string",
        "enum": [
          "capy/Unauthorized"
        ]
      }
    },
    "required": [
      "_tag"
    ],
    "additionalProperties": false
  },
  "capy_ForbiddenEncoded": {
    "type": "object",
    "properties": {
      "_tag": {
        "type": "string",
        "enum": [
          "capy/Forbidden"
        ]
      },
      "mfaRequiredOrgId": {
        "type": "string"
      },
      "ssoRequired": {
        "type": "boolean"
      },
      "passkeyRequired": {
        "type": "boolean"
      }
    },
    "required": [
      "_tag"
    ],
    "additionalProperties": false
  },
  "capy_AutomationNotFoundEncoded": {
    "type": "object",
    "properties": {
      "_tag": {
        "type": "string",
        "enum": [
          "capy/AutomationNotFound"
        ]
      },
      "automationId": {
        "type": "string"
      }
    },
    "required": [
      "_tag",
      "automationId"
    ],
    "additionalProperties": false
  },
  "capy_RateLimitedEncoded": {
    "type": "object",
    "properties": {
      "_tag": {
        "type": "string",
        "enum": [
          "capy/RateLimited"
        ]
      },
      "retryAfterSeconds": {
        "type": "integer"
      }
    },
    "required": [
      "_tag",
      "retryAfterSeconds"
    ],
    "additionalProperties": false
  }
}
```

Full document: https://docs.capy.ai/openapi.json