> For the complete documentation index, see [llms.txt](https://docs.flora.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.flora.ai/api/reference/canvas/getcanvasaction.md).

# Get a canvas action

Get a canvas action with the FLORA API: GET /projects/{projectId}/actions/{nodeId}.

Describes one canvas action node: its declared inputs, outputs and parameter controls (for a custom action, parsed from its code), the parameter values stored on the node, and the nodes wired into it.

```http
GET https://app.flora.ai/api/v1/projects/{projectId}/actions/{nodeId}
```

* **Auth:** API key as a bearer token, `Authorization: Bearer $FLORA_API_KEY`. See [Authentication](https://docs.flora.ai/api/platform/authentication.md).
* **TypeScript SDK:** `client.projects.actions.retrieve()`.
* **Operation ID:** `getCanvasAction`.

## Example

{% tabs %}
{% tab title="cURL" %}

```bash
curl -X GET 'https://app.flora.ai/api/v1/projects/prj_abc123/actions/<nodeId>' \
  -H "Authorization: Bearer $FLORA_API_KEY"
```

{% endtab %}

{% tab title="TypeScript SDK" %}

```typescript
import { FloraClient } from '@flora-ai/flora';

const client = new FloraClient({ apiKey: process.env['FLORA_API_KEY'] });

const action = await client.projects.actions.retrieve({
  projectId: 'prj_abc123',
  nodeId: '<nodeId>',
});
console.log(action);
```

{% endtab %}
{% endtabs %}

## Path parameters

| Name        | Type   | Required | Description                                                                                                          |
| ----------- | ------ | -------- | -------------------------------------------------------------------------------------------------------------------- |
| `projectId` | string | Yes      | Project identifier. Pattern: `^prj_\S+$`. Example: `prj_abc123`.                                                     |
| `nodeId`    | string | Yes      | Canvas action node identifier: the persisted short id (n7) or the node UUID. At least 1 character. Pattern: `^\S+$`. |

## Responses

### 200: Canvas action.

| Field                                     | Type                        | Required | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------------------- | --------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `project_id`                              | string                      | Yes      | Project identifier. Pattern: `^prj_\S+$`. Example: `prj_abc123`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `node_id`                                 | string                      | Yes      | Canvas action node UUID. At least 1 character. Example: `4d2f7c7e-1b1a-4c7f-9e1d-5b9d1f3b2c10`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `short_id`                                | string or null              | Yes      | Persisted short id (n7) of the node, when settled                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `action_id`                               | string or null              | Yes      | Prebuilt action identifier, or null for a custom action created from code. One of: `color-grade-image-browser`, `overlay-image-browser`, `draw-image-browser`, `pixel-remover-image-browser`, `magic-eraser-image-browser`, `crop-image-browser`, `scene-3d-image-browser`, `blur-image-browser`, `change-image-ar-browser`, `rotate-image-browser`, `color-filter-image-browser`, `color-tint-image-browser`, `filter-color-image-browser`, `duplicate-image-browser`, `side-by-side-composite-browser`, `add-shape-to-image-browser`, `add-text-to-image-browser`, `qr-code-generator-browser`, `resize-image-browser`, `shader-effect-browser`, `split-text-browser`, `find-and-replace-text-browser`, `concat-text-browser`, `ken-burns-video`, `stitch-videos`, `split-video`, `extract-video-frames`, `color-grade-video`, `video-to-frame-grid`, `boomerang-video`, `reverse-video`, `video-to-long-exposure`, `video-effect`, `color-filter-video`, `speed-up-video`, `slow-down-video`, `duplicate-video`, `greenscreen-video`, `resize-video`, `change-video-ar`, and 2 more. |
| `custom`                                  | boolean                     | Yes      | True when the node runs its own code rather than a prebuilt action                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `name`                                    | string                      | Yes      | Action name. Example: `Poster palette`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `description`                             | string                      | Yes      | Action description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `language`                                | string                      | Yes      | Action source language. One of: `javascript`, `python`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `runtime`                                 | string                      | Yes      | Where the action executes: a server sandbox (node, python) or the browser runtime (browser), which a host can also run live. One of: `node`, `python`, `browser`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `has_preview`                             | boolean                     | Yes      | True when the code is a browser-runtime module exporting `preview`, so a host can mount it live and re-render edits without a run                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `code`                                    | string or null              | Yes      | The node's source: registry code for a prebuilt action, the saved snippet for a custom one. Null when the snippet could not be read.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `tool_state`                              | any or null                 | No       | Interaction state the node's live preview last committed (JSON), replayed by its runs; null when none                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `charged_cost`                            | number                      | Yes      | Cost per execution in USD. At least 0.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `locked`                                  | boolean                     | Yes      | True when the node is locked and cannot be run or edited                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `inputs`                                  | array of objects            | Yes      | Action input slots                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `inputs[].name`                           | string                      | Yes      | Action input or output name. Example: `image`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `inputs[].type`                           | string                      | Yes      | Action input or output media type. One of: `image`, `video`, `text`, `audio`, `model3d`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `inputs[].dynamic`                        | boolean                     | No       | Deprecated alias for `multiple: true`. Mirrors `multiple` for back-compat.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `inputs[].optional`                       | boolean                     | No       | Whether the slot allows zero connections in single-input mode. Ignored when `multiple` is the object form (use `min: 0` there instead).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `inputs[].multiple`                       | boolean or object           | No       | Many-connections form. `true` is unbounded shorthand; the object form sets explicit min/max bounds. See the `inputs[].multiple` shapes below.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `outputs`                                 | array of objects            | Yes      | Action output slots                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `outputs[].name`                          | string                      | Yes      | Action input or output name. Example: `image`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `outputs[].type`                          | string                      | Yes      | Action input or output media type. One of: `image`, `video`, `text`, `audio`, `model3d`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `outputs[].dynamic`                       | boolean                     | No       | Deprecated alias for `multiple: true`. Mirrors `multiple` for back-compat.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `outputs[].optional`                      | boolean                     | No       | Whether the slot allows zero connections in single-input mode. Ignored when `multiple` is the object form (use `min: 0` there instead).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `outputs[].multiple`                      | boolean or object           | No       | Many-connections form. `true` is unbounded shorthand; the object form sets explicit min/max bounds. Same shape as `inputs[].multiple`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `params`                                  | array of objects            | Yes      | Action parameters (snake\_case keys)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `params[].key`                            | string                      | Yes      | Action parameter key. Example: `angle`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `params[].type`                           | string                      | Yes      | Action parameter control type. Example: `select`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `params[].label`                          | string                      | No       | Action parameter label. Example: `Angle`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `params[].info_tooltip`                   | string                      | No       | Action parameter description. Example: `Rotation angle in degrees.`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `params[].default_value`                  | any                         | No       | Default parameter value                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `params[].available_values`               | array of objects            | No       | Allowed parameter values                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `params[].available_values[].value`       | string                      | Yes      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `params[].available_values[].label`       | string                      | Yes      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `params[].available_values[].description` | string                      | No       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `params[].min_number_value`               | number                      | No       | Lowest accepted number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `params[].max_number_value`               | number                      | No       | Highest accepted number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `params[].number_step`                    | number                      | No       | Step between accepted numbers                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `params[].placeholder`                    | string                      | No       | Placeholder shown in an empty text control                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `params[].max_count`                      | integer                     | No       | For colorList controls: how many colors the value may hold. At least 0.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `params[].visible_if`                     | array of objects            | No       | Conditions under which a control is shown, all of which must hold. Keys are the snake\_case keys of this same params list.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `params[].visible_if[].key`               | string                      | Yes      | Key of the parameter this condition reads                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `params[].visible_if[].equals`            | string or number or boolean | No       | Show this parameter only when the other parameter equals this value                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].visible_if[].not_equals`        | string or number or boolean | No       | Show this parameter only when the other parameter differs from this value                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `params[].point2d_min`                    | object                      | No       | Per-axis minimum for point2d values                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].point2d_min.x`                  | number                      | No       | Bound on the x axis                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].point2d_min.y`                  | number                      | No       | Bound on the y axis                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].point2d_min.z`                  | number                      | No       | Bound on the z axis (point3d only)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `params[].point2d_max`                    | object                      | No       | Per-axis maximum for point2d values                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].point2d_max.x`                  | number                      | No       | Bound on the x axis                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].point2d_max.y`                  | number                      | No       | Bound on the y axis                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].point2d_max.z`                  | number                      | No       | Bound on the z axis (point3d only)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `params[].point2d_step`                   | object                      | No       | Per-axis step for point2d values                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `params[].point2d_step.x`                 | number                      | No       | Bound on the x axis                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].point2d_step.y`                 | number                      | No       | Bound on the y axis                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].point2d_step.z`                 | number                      | No       | Bound on the z axis (point3d only)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `params[].point3d_min`                    | object                      | No       | Per-axis minimum for point3d values                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].point3d_min.x`                  | number                      | No       | Bound on the x axis                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].point3d_min.y`                  | number                      | No       | Bound on the y axis                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].point3d_min.z`                  | number                      | No       | Bound on the z axis (point3d only)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `params[].point3d_max`                    | object                      | No       | Per-axis maximum for point3d values                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].point3d_max.x`                  | number                      | No       | Bound on the x axis                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].point3d_max.y`                  | number                      | No       | Bound on the y axis                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].point3d_max.z`                  | number                      | No       | Bound on the z axis (point3d only)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `params[].point3d_step`                   | object                      | No       | Per-axis step for point3d values                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `params[].point3d_step.x`                 | number                      | No       | Bound on the x axis                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].point3d_step.y`                 | number                      | No       | Bound on the y axis                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `params[].point3d_step.z`                 | number                      | No       | Bound on the z axis (point3d only)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `param_values`                            | object                      | Yes      | Parameter values stored on the node, keyed like params\[].key; defaults apply for missing keys                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `connected_inputs`                        | array of objects            | Yes      | Nodes wired into this action, in edge order                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `connected_inputs[].node_id`              | string                      | Yes      | Short id (n7) or UUID of the connected node. Example: `n3`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `connected_inputs[].label`                | string or null              | Yes      | Connected node label                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `connected_inputs[].type`                 | string or null              | Yes      | Media type the connected node currently supplies, null until it has an output. One of: `image`, `video`, `text`, `audio`, `model3d`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `connected_inputs[].url`                  | string or null              | Yes      | Current output URL of the connected node                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `connected_inputs[].text`                 | string or null              | Yes      | Current text output of the connected node                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `canvas_url`                              | string (uri)                | Yes      | Project canvas URL                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |

<details>

<summary>inputs[].multiple shapes</summary>

Field paths in this block are relative to `inputs[].multiple`.

`inputs[].multiple` takes one of 2 shapes.

**Shape 1: Boolean.** Always `true`.

**Shape 2: Object.**

| Field | Type    | Required | Description |
| ----- | ------- | -------- | ----------- |
| `min` | integer | No       | At least 0. |
| `max` | integer | No       | At least 0. |

</details>

## Errors

Every error has the same body: `error.code`, `error.message`, and `error.fields` on validation errors. See [Errors](https://docs.flora.ai/api/platform/errors.md) for how to recover from each code.

| Status | Code                                         | Meaning                                                                             |
| ------ | -------------------------------------------- | ----------------------------------------------------------------------------------- |
| 400    | `invalid_json`, `input_validation_error`     | The body isn't valid JSON, or an input failed validation (`fields` lists each one). |
| 401    | `unauthorized`, `invalid_api_key`            | The API key is missing, invalid or revoked.                                         |
| 402    | `insufficient_credits`                       | The workspace balance is too low for this request.                                  |
| 403    | `forbidden`, `paid_plan_required`            | The key can't do this, or the workspace plan doesn't include it.                    |
| 404    | `not_found`                                  | The resource doesn't exist or isn't visible to this key.                            |
| 409    | `idempotency_duplicate`, `revision_conflict` | Duplicate `Idempotency-Key` or a stale `base_revision`.                             |
| 429    | `rate_limited`                               | Too many requests. Back off and retry.                                              |
| 500    | `unknown_error`, `internal_error`            | Something failed on FLORA's side. Retry with backoff.                               |
| 503    | `temporarily_unavailable`                    | Authorization is temporarily unavailable. Retry later.                              |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.flora.ai/api/reference/canvas/getcanvasaction.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
