> For the complete documentation index, see [llms.txt](https://docs.pyck.cloud/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.pyck.cloud/graphql-api/inputs/workflowactionswhereinput.md).

# WorkflowActionsWhereInput

Optional filter to narrow down which workflow actions are returned

Audience: Programmer

Optional filter for the [`workflowActions`](/graphql-api/queries/workflowactions.md) query. When provided, it narrows the list of returned queries and updates to those matching the specified criteria.

## Fields

### Name predicates

| Field              | Type        | Required | Description                                                                                          |
| ------------------ | ----------- | -------- | ---------------------------------------------------------------------------------------------------- |
| `name`             | `String`    | No       | Exact-match filter on the action name. When set, only the query or update with this name is returned |
| `nameNEQ`          | `String`    | No       | Matches actions whose name is **not** equal to the value                                             |
| `nameIn`           | `[String!]` | No       | Matches actions whose name is in the provided list                                                   |
| `nameNotIn`        | `[String!]` | No       | Matches actions whose name is **not** in the provided list                                           |
| `nameContains`     | `String`    | No       | Matches actions whose name contains the substring (case-sensitive)                                   |
| `nameHasPrefix`    | `String`    | No       | Matches actions whose name starts with the prefix (case-sensitive)                                   |
| `nameHasSuffix`    | `String`    | No       | Matches actions whose name ends with the suffix (case-sensitive)                                     |
| `nameEqualFold`    | `String`    | No       | Matches actions whose name equals the value, ignoring case                                           |
| `nameContainsFold` | `String`    | No       | Matches actions whose name contains the substring, ignoring case                                     |

### Other predicates

| Field     | Type      | Required | Description                                                                                                                                                |
| --------- | --------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `enabled` | `Boolean` | No       | Filter by the `enabled` flag. Pass `true` to only return currently callable actions, or `false` for actions that are registered but not currently callable |

## Usage

All fields are optional. Omitting the `where` argument, or passing an empty object, returns every registered query and update.

### How predicates are combined

Predicates are **AND-joined**: an action is returned only if it satisfies *every* predicate you set. For example, `{ nameHasPrefix: "ship", enabled: true }` returns only actions whose name starts with `ship` **and** that are currently callable.

A predicate that is left unset is ignored and matches every action. The following are all treated as "unset":

* A field that is omitted entirely.
* A `null` value.
* An empty string (`""`) for the string predicates.
* An empty list (`[]`) for `nameIn` and `nameNotIn`.

This means passing an empty `where` object, or a `where` whose fields are all empty/null, behaves identically to omitting the filter: every registered query and update is returned.

### Case sensitivity

The substring and equality predicates come in two flavors:

* **Case-sensitive**: `name`, `nameNEQ`, `nameIn`, `nameNotIn`, `nameContains`, `nameHasPrefix`, `nameHasSuffix`.
* **Case-insensitive**: `nameEqualFold` (full match) and `nameContainsFold` (substring).

Use the `Fold` variants when you cannot rely on the exact casing of action names.

### Example: filter by enabled state

```graphql
query {
  workflowActions(
    input: {
      workflowId: "order-processing-workflow-123"
      workflowExecutionId: "run-456-xyz"
    }
    where: { enabled: true }
  ) {
    queries {
      name
      description
      enabled
    }
    updates {
      name
      description
      enabled
    }
  }
}
```

### Example: fetch a single action by name

```graphql
query {
  workflowActions(
    input: {
      workflowId: "order-processing-workflow-123"
      workflowExecutionId: "run-456-xyz"
    }
    where: { name: "confirmPick" }
  ) {
    updates {
      name
      description
      enabled
    }
  }
}
```

### Example: filter by name prefix

Return every callable action whose name starts with `ship`:

```graphql
query {
  workflowActions(
    input: {
      workflowId: "order-processing-workflow-123"
      workflowExecutionId: "run-456-xyz"
    }
    where: {
      nameHasPrefix: "ship"
      enabled: true
    }
  ) {
    updates {
      name
      description
      enabled
    }
  }
}
```

### Example: substring and list predicates

Return actions whose name contains `Pick` (case-sensitive) and is one of a known set:

```graphql
query {
  workflowActions(
    input: {
      workflowId: "order-processing-workflow-123"
      workflowExecutionId: "run-456-xyz"
    }
    where: {
      nameContains: "Pick"
      nameIn: ["confirmPick", "skipPick", "reassignPick"]
    }
  ) {
    updates {
      name
      enabled
    }
  }
}
```

### Example: combine filters

Because predicates are AND-joined, you can stack them to narrow the result precisely:

```graphql
query {
  workflowActions(
    input: {
      workflowId: "order-processing-workflow-123"
      workflowExecutionId: "run-456-xyz"
    }
    where: {
      name: "confirmPick"
      enabled: true
    }
  ) {
    updates {
      name
      enabled
    }
  }
}
```

## Notes

* The filter applies to both the `queries` and `updates` lists in the response.
* All predicates are AND-joined; an action must satisfy every predicate you set to be returned.
* Unlike execution filtering, action definitions are filtered in memory after the full set is fetched, so each predicate is evaluated directly against the action name.
* Because a workflow's action set changes as it progresses, filtering by `enabled: true` is the most reliable way to discover what a client can currently invoke.

## Related

* Query: [workflowActions](/graphql-api/queries/workflowactions.md)
* Input: [GetWorkflowActionsInput](/graphql-api/inputs/getworkflowactionsinput.md)
* Type: [GetWorkflowActionsResponse](/graphql-api/types/getworkflowactionsresponse.md)
* Type: [ActionDefinition](/graphql-api/types/actiondefinition.md)

## Service

This input type is defined in the **workflow** service.


---

# 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.pyck.cloud/graphql-api/inputs/workflowactionswhereinput.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.