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

# Execution tags

> Correlate runs with request IDs and find their outputs later.

Tags are string labels stored on workflow and agent executions. Use request IDs, queue names, or batch IDs to find related runs. Tags are separate from automation inputs.

## Studio

On **Trigger**, enter one execution tag per line before starting a run. On **Runs**, enter an exact tag in the tag filter. Clicking a tag in run details opens matching history.

**Connect → Start run** documents the `tags` request field. Enter example tags to generate matching REST, TypeScript, and Python requests. **Connect → List runs** documents the `tag` filter.

## API

```bash theme={null}
curl "$EIGENPAL_BASE_URL/api/v1/runs" \
  -H "Authorization: Bearer $EIGENPAL_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{"target":"workflows.process-request","input":{"requestId":"request-123"},"tags":["request-123","batch-7"]}'
```

The `tags` field accepts either one string or a string array. For multipart requests, send the field as JSON, for example `-F 'tags=["request-123","batch-7"]'`.

Find runs with `GET /api/v1/runs?tag=request-123`, then retrieve their outputs using `GET /api/v1/runs/{id}`. List and detail responses include the stored `tags` array.

## SDKs

```typescript theme={null}
await client.run(
  'workflows.process-request',
  { requestId: 'request-123' },
  {
    tags: ['request-123', 'batch-7'],
  }
);
const page = await client.runs.list({ tag: 'request-123' });
```

```python theme={null}
client.run('workflows.process-request', input={'requestId': 'request-123'},
           tags=['request-123', 'batch-7'])
page = client.runs.list(tag='request-123')
```

## CLI

```bash theme={null}
eigenpal run workflows.process-request \
  --input-json '{"requestId":"request-123"}' \
  --tag request-123 --tag batch-7 --wait --json
eigenpal runs list --tag request-123 --json
```

The start flag applies to ad-hoc runs, including runs with uploaded files. Dataset example runs do not accept `--tag`.

## Child workflows

Select **Child execution** in an Invoke workflow step, then enter a JSON array or one expression returning an array in **Execution tags**. The array length can change between runs.

```yaml theme={null}
type: action.invoke-workflow
with:
  workflow: process-request
  execution: child
  wait: false
  tags:
    - '{{ input.requestId }}'
    - batch-7
  input:
    requestId: '{{ input.requestId }}'
```

Tags apply to the child execution. Inline invocations do not create a separate execution and reject tags. Children do not inherit parent tags; pass the tags explicitly.

Combine two dynamic arrays in the field:

```liquid theme={null}
{{ input.tags | concat: input.additionalTags }}
```

For a literal array, enter `["request-123", "batch-7"]`. You can also reference an array from a previous step, such as `{{ steps.extract.output.tags }}`. No fixed number of tag rows is required.

## Matching and limits

* Matching is exact and case-sensitive. `Request-123` and `request-123` differ.
* Commas and whitespace are part of the tag. Tags are never split on commas or trimmed.
* Duplicate tags are removed. Empty or whitespace-only tags are rejected.
* Up to 100 submitted tags, with up to 256 characters per tag.
* Existing and untagged runs have `tags: []`. Retries and reruns preserve tags.

Numeric IDs resolved by templates in child invocation steps are converted to strings
before validation. The REST API and SDK inputs still require string tags.
Multipart requests can send a single plain tag (`-F 'tags=request-123'`) or a
JSON string array (`-F 'tags=["request-123","batch-7"]'`).


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