> For the complete documentation index, see [llms.txt](https://support.attackforge.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://support.attackforge.com/app/automations-and-integrations/flows.md).

# Flows

## Overview

Flows is AttackForge's end-to-end workflow automation engine, powered by [AFScript](https://support.attackforge.com/app/automations-and-integrations/afscript). Use it to connect AttackForge with the other systems your team uses, and to automate the work in between.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FpK8c34EPQX4IcrIBroWQ%2F1.png?alt=media&amp;token=f6fa2b04-1607-49d9-baa1-6abad9c8802d" alt=""><figcaption></figcaption></figure>

For example, you can use Flows to:

| Use case                                                | Examples                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Build custom workflows**                              | Your own processes, approvals and reminders                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **Run AI agentic workflows**                            | Start an AI agent from an [Action](https://support.attackforge.com/app/automations-and-integrations/actions.md), and let it read from and write back to AttackForge through [AI MCP](https://support.attackforge.com/app/automations-and-integrations/ai-mcp-and-skills): enrich vulnerabilities, run penetration tests, retest findings, write executive summaries, and analyse attack chains. See [AI agentic workflows](https://support.attackforge.com/app/automations-and-integrations/ai-agentic-workflows). |
| **Prioritise vulnerabilities with threat intelligence** | [Flashpoint](https://flashpoint.io/ignite/vulnerability-intelligence/)                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| **Send vulnerabilities to ticketing systems**           | [Jira](https://www.atlassian.com/software/jira), [ServiceNow](https://www.servicenow.com/), [Azure DevOps](https://azure.microsoft.com/en-us/products/devops), [BMC Helix](https://www.bmc.com/it-solutions/bmc-helix.html)                                                                                                                                                                                                                                                                                        |
| **Send data to BI and reporting tools**                 | [Power BI](https://www.microsoft.com/en-us/power-platform/products/power-bi), [Tableau](https://www.tableau.com/)                                                                                                                                                                                                                                                                                                                                                                                                  |
| **Sync bug bounty findings**                            | [HackerOne](https://hackerone.com/), [Bugcrowd](https://www.bugcrowd.com/)                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| **Sync with GRC tools**                                 | [Archer](https://www.archerirm.com/), [MetricStream](https://www.metricstream.com/), [OneTrust](https://www.onetrust.com/), [LogicGate](https://www.logicgate.com/)                                                                                                                                                                                                                                                                                                                                                |
| **Chain Self-Service API calls**                        | Several [Self-Service RESTful API](https://support.attackforge.com/app/automations-and-integrations/self-service-restful-api) calls in one automation                                                                                                                                                                                                                                                                                                                                                              |
| **Trigger and import scans**                            | [Rapid7](https://www.rapid7.com/), [Tenable](https://www.tenable.com/), [Qualys](https://www.qualys.com/)                                                                                                                                                                                                                                                                                                                                                                                                          |
| **Send chat messages**                                  | [Slack](https://slack.com/intl/en-au/), [Microsoft Teams](https://www.microsoft.com/en-au/microsoft-teams/group-chat-software)                                                                                                                                                                                                                                                                                                                                                                                     |
| **Send webhooks and custom emails**                     | Any system that accepts a webhook, or custom email notifications                                                                                                                                                                                                                                                                                                                                                                                                                                                   |

Watch the [Flows video](https://youtu.be/tTbq4Dbh-A8).

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FM5Vp2TUnhDy1042mdi4V%2Fflows-at-a-glance.svg?alt=media&amp;token=141bcf4a-e61c-4a51-9826-720c68eb28f4" alt=""><figcaption></figcaption></figure>

## Key terms

| Term           | Meaning                                                                                                                           |
| -------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| **Flow**       | An automation. It has a name, a trigger, a sequence of actions, and secrets.                                                      |
| **Trigger**    | What starts a Flow: an internal event, an external HTTP call, a schedule, or an Action clicked in the UI. A Flow has one trigger. |
| **Action**     | One step in a Flow: an HTTP request, or a script.                                                                                 |
| **Run**        | One execution of a Flow, from trigger to finish.                                                                                  |
| **Flow Owner** | The user a Flow belongs to and runs as.                                                                                           |
| **Secret**     | An encrypted value, such as an API key, used in headers or scripts.                                                               |

## Why it matters

* **Connect your tools.** Keep AttackForge in sync with ticketing, chat, BI, GRC and scanning tools, without manual copying.
* **Save time.** Automate repetitive steps, such as raising tickets for new findings or chasing overdue risk acceptances.
* **Fit your process.** Build workflows that match how your team works, not the other way round.
* **Stay in control.** Flows run with their owner's access, and every run is logged.

## Who uses it

| Who                                            | To                                                        |
| ---------------------------------------------- | --------------------------------------------------------- |
| **Administrators**                             | Grant access to Flows and events, and oversee automations |
| **Security engineers and automation builders** | Build and maintain Flows and integrations                 |
| **Security and practice leads**                | Automate team workflows, notifications and reporting      |
| **Testers and project managers**               | Run Flows from Actions in the UI                          |

## Get access to Flows

Flows is included with Enterprise and the Core SME plan. On other plans, add it from **Administration > Subscriptions**.

To build Flows, a user needs **Create** access to at least one trigger type. Administrators set this under **Users > (select user) > Access > Flows**.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FkWVBKjdsQVOfYsS5Fhwz%2FScreenshot%202026-11-11%20at%207.58.12%E2%80%AFam.png?alt=media&amp;token=95a387ea-f206-4baf-a6ef-622477334b14" alt=""><figcaption></figcaption></figure>

| Trigger type                                     | Access levels     | Notes                                                                                                                                                             |
| ------------------------------------------------ | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Event trigger**                                | None, Run, Create | The user also needs access to the matching event.                                                                                                                 |
| **HTTP trigger – Authentication (None)**         | None, Run, Create | For non-authenticated HTTP triggers.                                                                                                                              |
| **HTTP trigger – Authentication (User API Key)** | None, Run, Create | For authenticated HTTP triggers. Callers need a valid [User Key](https://support.attackforge.com/attackforge-enterprise/getting-started/manage-user#user-api-key) |
| **Schedule trigger**                             | None, Run, Create |                                                                                                                                                                   |
| **Action trigger**                               | None, Run, Create |                                                                                                                                                                   |

{% hint style="info" %}
Run allows a user to trigger a Flow, however does not allow them to create their own flows.
{% endhint %}

## Get access to events

To use event triggers, a user also needs access to the events. Administrators enable this under **Users > (select user) > Access > Events**. See [Self-Service Events API](https://support.attackforge.com/app/automations-and-integrations/self-service-events-api).

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FZsQ63aw3gDGPuC0B8iTe%2FScreenshot%202026-11-11%20at%208.00.56%E2%80%AFam.png?alt=media&amp;token=5841877a-89fd-497d-8fe3-281dc8598d4c" alt=""><figcaption></figcaption></figure>

## Build your first Flow

This walkthrough uses the page's Jira example: when a vulnerability is created, raise a Jira issue, then save the issue key back on the vulnerability.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FYwz70jE5OnpJHQGqeEyA%2Fflows-build-your-first-flow.svg?alt=media&amp;token=95fb81a8-0d02-4819-a226-1cccd020daef" alt=""><figcaption></figcaption></figure>

1. **Create the Flow** and give it a name.
2. **Choose a trigger.** Pick an internal event for new vulnerabilities e.g. `vulnerability-created`
3. **Add secrets** for your Jira and AttackForge API credentials.
4. **Add Action 1: an HTTP Action** that [creates a Jira issue](https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issues/#api-rest-api-3-issue-post). Use the Request Script to build the issue from the vulnerability data.
5. **Add Action 2: an HTTP Action** that [updates the vulnerability](https://docs.attackforge.com/rest-api/methods/updateVulnerabilityById), writing the Jira issue key into a custom field.
6. **Test it** with Manually Run Flow and test data.
7. **Enable it,** then watch its runs in Run Logs.

The sections below explain each part.

## Flow overview

Each Flow is made up of:

* **Name**
* **Trigger**
* **Actions**, run in sequence
* **Secrets**

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FB845IlB2ksdeiqwtVP0y%2FScreenshot%202026-11-11%20at%208.03.29%E2%80%AFam.png?alt=media&amp;token=96935cf6-5f24-4b7f-8e8b-c9db8db7f988" alt=""><figcaption></figcaption></figure>

## Triggers

A trigger starts a Flow Run. It can be an event, or a manual run. See also [Self-Service Events API](https://support.attackforge.com/app/automations-and-integrations/self-service-events-api).

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fgb8Vj5FXIoTq1SwxqP1V%2FScreenshot%202026-11-11%20at%208.04.16%E2%80%AFam.png?alt=media&amp;token=0fee4456-1384-4c1b-ba8a-5a41aa40ccb1" alt=""><figcaption></figcaption></figure>

| Trigger                             | Starts when                                                                                                                                                                                           | Example                                                                                                             |
| ----------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
| **Internal Events**                 | Something changes in AttackForge                                                                                                                                                                      | A vulnerability is created                                                                                          |
| **External Events (HTTP triggers)** | An external system sends data, such as a [webhook](https://hookdeck.com/webhooks/guides/what-are-webhooks-how-they-work). Other Flows can call them too.                                              | A scanner sends results                                                                                             |
| **Scheduled Events**                | At a set time, such as daily at 9 am or hourly                                                                                                                                                        | Every day, find vulnerabilities past their risk-acceptance date, reopen them, create a ticket and notify the owners |
| **Action Events**                   | A user clicks an [Action](https://support.attackforge.com/app/automations-and-integrations/actions) in the UI. You can limit it to specific entities, so the Action appears only where it's relevant. | A "Send to Jira" button on vulnerabilities (example)                                                                |

### Internal Events

Internal events happen when something changes inside AttackForge. Access to them is granted to users or groups. See [Events docs](https://docs.attackforge.com/events-api) for a list of all supported events.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fwas1ojEuYUGwAoteUBES%2Fflows-internal-events.svg?alt=media&amp;token=da8ba75f-ed3f-4eba-8687-6c928c778037" alt=""><figcaption></figcaption></figure>

### External Events

External events are HTTP triggers. They start a Flow when an external system sends data, typically through webhooks. They can also be called from other Flows.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FxkYf2jjmbstr2Gn7XUWH%2Fflows-external-events.svg?alt=media&amp;token=c62ee35f-83ff-4d8a-bca6-eba58642a975" alt=""><figcaption></figcaption></figure>

### Scheduled Events

Scheduled events start a Flow at set times, such as daily at 9 am or every hour.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FaXaBhbfIhhXCkUlUWXZQ%2Fflows-scheduled-events.svg?alt=media&amp;token=ba5a1ce3-537d-4692-be31-2a40ea627b44" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2F35RygNMxx9Iy32tdWBrx%2FScreenshot%202026-11-11%20at%208.07.07%E2%80%AFam.png?alt=media&amp;token=c5ea531f-6ab1-4ca9-a5b9-f67237f03c7b" alt=""><figcaption></figcaption></figure>

### Action Events

Action events start a Flow when a user clicks an Action in the AttackForge interface. You can scope them to specific entities, so the Action appears only where it's relevant.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FIPfrefEx1S8qiqB2CaM4%2Fflows-action-events.svg?alt=media&amp;token=931ab0c1-9ddc-47a7-b7b3-6328d48c3591" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2F0c9oEez8yuTCKgu81F4f%2FScreenshot%202026-11-11%20at%208.08.15%E2%80%AFam.png?alt=media&amp;token=e108780d-60f3-4e4b-8f4f-2b49d21ab240" alt=""><figcaption></figcaption></figure>

### Assign a trigger

A Flow can have only one trigger. You assign it when you create or edit the Flow.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FfilKGW1PIsbCkJ7Oi1vx%2FScreenshot%202026-11-11%20at%208.51.40%E2%80%AFam.png?alt=media&amp;token=121e84bf-1e79-42a5-8e51-09c0130edb59" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2F71SkqL82TAf0pLDQCa3e%2FScreenshot%202026-11-11%20at%208.51.48%E2%80%AFam.png?alt=media&amp;token=36cdbb4e-9a8b-4cfb-ba1f-9b269eb02e25" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FX94AUekzzhbry2a8Wov0%2FScreenshot%202026-11-11%20at%208.52.03%E2%80%AFam.png?alt=media&amp;token=cf3aef71-a622-4120-9e9b-c84a164d63e0" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FMZcdvnUdq4EycdUuVFkJ%2FScreenshot%202026-11-11%20at%208.52.22%E2%80%AFam.png?alt=media&amp;token=c8dd3d1b-9c3e-472a-8475-57d5b999bec1" alt=""><figcaption></figcaption></figure>

### HTTP trigger authentication

HTTP triggers can be:

* **Authenticated:** the caller's User Key is checked in a custom header.
* **Non-authenticated:** anyone with the Trigger URL can call it.

Callers need Trigger access to the Flow, unless they're the Flow Owner. See "Trigger access" below.

### HTTP trigger URL

Each HTTP trigger has a unique **Trigger URL** and **Trigger ID**. If the trigger is non-authenticated, treat them as secrets. Click **Regenerate** to rotate both.

### Trigger configuration

Choose what's redacted from the incoming request in run logs:

| Option                                  | What it does                                         |
| --------------------------------------- | ---------------------------------------------------- |
| **Redact user API Key**                 | Hides the caller's User Key                          |
| **Redact all headers except specified** | Hides every header except those you list (allowlist) |
| **Redact specified headers**            | Hides only the headers you list (blocklist)          |

## Actions

An Action is a single activity, or a sequence of activities run in order during a Flow Run. The output of each Action becomes the input to the next.

For example, a Flow that sends a vulnerability to Jira has two Actions:

1. [Create the Jira issue](https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issues/#api-rest-api-3-issue-post).
2. Write the Jira issue key back to the vulnerability, using the [Update Vulnerability](https://docs.attackforge.com/rest-api/methods/updateVulnerabilityById) Self-Service API.

### Action types

| Type              | What it does                                                                                                                                                                                                                          |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **HTTP Action**   | Sends an HTTP request to a Self-Service API or an external system, with optional scripts before and after. See [Self-Service RESTful API](https://support.attackforge.com/app/automations-and-integrations/self-service-restful-api). |
| **Script Action** | Runs your own logic, with no HTTP request. It receives Data from the previous Action and passes Data to the next.                                                                                                                     |

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2F1NPjeFaJJMEaFxC1rt5N%2FScreenshot%202026-11-11%20at%208.56.08%E2%80%AFam.png?alt=media&amp;token=8ba3cdf3-aa49-44d2-9329-08f0b982288c" alt=""><figcaption></figcaption></figure>

### Script Action

A Script Action has a single code editor. Use it between HTTP Actions to transform data or make decisions. For example: HTTP Action (fetch data) → Script Action (filter and reshape it) → HTTP Action (send it on).

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FjqjE5rCM7wfuiLWYqXxU%2FScreenshot%202026-11-11%20at%208.58.44%E2%80%AFam.png?alt=media&amp;token=8ebf0cc6-b823-41db-9d0c-500e3f82bf75" alt=""><figcaption></figcaption></figure>

### HTTP Action

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FRYKge50TkCF4fIQUO9bs%2FScreenshot%202026-11-11%20at%208.57.50%E2%80%AFam.png?alt=media&amp;token=378eadcf-e298-42f3-b304-a144538ed34c" alt=""><figcaption></figcaption></figure>

An HTTP Action is made up of a **Request** and a **Response**. You set:

| Part                   | What it is                                    |
| ---------------------- | --------------------------------------------- |
| **Method**             | GET, POST, PUT, PATCH or DELETE               |
| **URL**                | Where the request is sent                     |
| **Verify Certificate** | Whether to check the server's TLS certificate |
| **Headers**            | The request headers                           |
| **Request Script**     | Code that runs before the request is sent     |
| **Response Script**    | Code that runs after the response is received |

You can set the method, URL and headers in the Action, or work them out in the Request Script and return them.

#### **Methods**

Supported methods are GET, POST, PUT, PATCH and DELETE. You can also set the method in the Request Script's return statement:

```javascript
return {
    decision: { 
        status: 'continue'
    },
    request: {
        url: url,
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Accept': 'application/json',
            'Authorization': secrets.jira_auth
        },
        body: {
            fields: {
                summary: summary,
                description: description,
                priority: {
                    name: priority
                },
                issuetype: {
                    name: 'Bug'
                },
                labels: labels
            }
        }
    }
};
```

#### **URL**

The URL is where the request is sent. Set it in the Action, or build it in the Request Script. This is useful when part of the URL changes, such as an ID:

```javascript
const url = `https://tenant.attackforge.com/api/ss/vulnerability/${data.vulnerability_id}`;

return {
    decision: { 
        status: 'continue'
    },
    request: {
        url: url,
        method: 'PUT',
        headers: {
            'Content-Type': 'application/json',
            'x-ssapi-key': secrets.af_auth
        },
        body: {
            project_id: project_id,
            custom_fields: [
                {
                    key: 'jira_issue_key',
                    value: jira_issue_key
                }
            ]
        }
    }
};
```

#### **Headers**

Set headers in the Action, or build them in the Request Script:

```javascript
const customHeaderName = 'X_CUSTOM_HEADER_' + customHeader;
const customHeaderValue = customValue;

return {
    decision: { 
        status: 'continue'
    },
    request: {
        url: url,
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            customHeaderName: customHeaderValue,
            'Authorization': secrets.custom_auth
        },
        body: {
            super_secret_something: "..."
        }
    }
};
```

#### **Request and response**

|                     | Made up of                                                                               |
| ------------------- | ---------------------------------------------------------------------------------------- |
| **Request**         | An HTTP or HTTPS request: URL, Method, Headers, an optional Body, and the Request Script |
| **Response**        | The server's reply: the Response Object, and the Response Script                         |
| **Request Script**  | Code, Data and a Return Statement. Runs before the request.                              |
| **Response Script** | Code, Data and a Return Statement. Runs after the response.                              |

## Scripts

### Code

Scripts are written in [AFScript](https://support.attackforge.com/app/automations-and-integrations/afscript). You can:

* **Log** values to the run logs. See [AFScript logging](https://support.attackforge.com/app/automations-and-integrations/afscript)
* **Click Run** to test a script.
* **See stack traces** when a script fails.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FPfLaKe6EExM22rzaGZTI%2FScreenshot%202026-11-11%20at%209.03.48%E2%80%AFam.png?alt=media&amp;token=6acc8e60-d969-42f9-84dc-39cadf50eff3" alt=""><figcaption></figcaption></figure>

### Data

Data is the context passed between scripts and Actions. Reference a value with:

```javascript
data.<KEY>
```

### The Data object

The Data object holds Data. In the first Action, it holds the event's fields, such as the vulnerability's data. Each step can add to it or override it for the next step.

Reference a value:

```javascript
data.<KEY>
```

For example, store the vulnerability ID:

```javascript
const vuln_id = data.vulnerability_id;
```

Find the project ID in the vulnerability's list of projects:

```javascript
let project_id;

if (data.vulnerability_projects) {
    for (const project of data.vulnerability_projects) {
        if (project.id) {
            project_id = project.id;
        }
    }
}
```

Pass values to the next step in the `data` key of the return statement:

```javascript
return {
    decision: { 
        status: 'continue'
    },
    data: {
        af_project_id: project_id,
        af_vuln_id: vuln_id,
        af_vuln: data
    }
}
```

The Data object in the Response Script is then:

```javascript
data = {
    af_project_id: "...",
    af_vuln_id: "...",
    af_vuln: {
        "vulnerability_title": "...",
        ...
    }
}
```

To see the Data object, log it. The output appears in Run Logs:

```javascript
Logger.debug('Data:');
Logger.debug(JSON.stringify(data));
```

You can also see each Action's Data in the run details, and set test data for Action Events.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FXA3JGxoiF6susd0py259%2FScreenshot%202026-11-11%20at%209.11.41%E2%80%AFam.png?alt=media&amp;token=c56c5b75-c85e-4c03-b5e3-36f0ab282dc7" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FVxsbrAR5wuJCq7gf2jhZ%2FScreenshot%202026-11-11%20at%209.08.51%E2%80%AFam.png?alt=media&amp;token=647c74a2-feb7-4ccb-a984-59368e396ae9" alt=""><figcaption></figcaption></figure>

### The Response object

The Response object holds the server's reply. Reference a value with:

```javascript
response.<KEY>
```

It has the following keys:

```json
{
  "response": {
    "statusCode": 200,
    "headers": {
      "Content-Type": "application/json"
    },
    "body": "{\"key\": \"value\"}",
    "jsonBody": {
      "key": "value"
    },
    "fileId": ""
  }
}
```

| Key          | What it holds                                                                     |
| ------------ | --------------------------------------------------------------------------------- |
| `statusCode` | The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status)  |
| `headers`    | The [response headers](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers) |
| `body`       | The response body, as a string                                                    |
| `jsonBody`   | The response body as a JSON structure (if JSON response)                          |
| `fileId`     | The id of the file, if a file was downloaded in the response                      |

If the body is JSON, parse it before you use it:

```javascript
const body = JSON.parse(response.body);
```

Or use the `jsonBody` directly:

```javascript
const body = response.jsonBody;
```

To see the Response object, log it:

```javascript
Logger.debug('Response:');
Logger.debug(JSON.stringify(response));
```

### The return statement

Every script ends with a return statement. It decides what happens next, and can change the request and pass data on. It has three parts:

| Part       | What it does                                                |
| ---------- | ----------------------------------------------------------- |
| `decision` | What happens next. See "Decision" below.                    |
| `request`  | Request Scripts only: changes the request before it's sent. |
| `data`     | Passes data to the next script or Action.                   |

```javascript
return {
   decision: { 
     status: 'continue', 
     message: 'Payload is valid, proceed to submit request', 
   }, 
   request: { 
     url: 'https://www.attackforge.com/api',
     body: {}, 
     headers: {}, 
     method: 'GET', 
   }, 
   data: {} 
};
```

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FhppHkW75xymbSck2U4eY%2FScreenshot%202026-11-11%20at%209.19.59%E2%80%AFam.png?alt=media&amp;token=240aed90-bac2-46d7-9dda-1f9817ab66ec" alt=""><figcaption></figcaption></figure>

#### **Decision**

| Status     | In a Request Script                                                                                                                           | In a Response Script        |
| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------- |
| `continue` | Sends the request                                                                                                                             | Runs the next Action        |
| `next`     | Skips to the next Action, without sending the request. Use it for conditional steps.                                                          | Skips to the next Action    |
| `repeat`   | Runs the Action again. Use it to process a list, page through results, or retry with an updated payload. You can change Data between repeats. | Same as in a Request Script |
| `abort`    | Ends the Flow with an error                                                                                                                   | Ends the Flow with an error |
| `finish`   | Ends the Flow successfully                                                                                                                    | Ends the Flow successfully  |

The Request Script and Response Script behaviour for `next` and `repeat`.

| Field     | Required | Description                                                                                                 |
| --------- | -------- | ----------------------------------------------------------------------------------------------------------- |
| `status`  | Yes      | One of the statuses above.                                                                                  |
| `message` | No       | A message for the run logs.                                                                                 |
| `delay`   | No       | How long to wait before the decision takes effect, in milliseconds. Minimum 0, maximum 86400000 (24 hours). |

```javascript
return {
   decision: { 
     status: 'continue', 
     message: 'Payload is valid, proceed to submit request', 
   }
};
```

With a delay:

```javascript
return {
   decision: { 
     status: 'continue', 
     message: 'Payload is valid, wait 5 seconds then proceed to submit request',
     delay: 5000 
   }
};
```

As a string:

```javascript
return {
   decision: "continue"
};
```

**Continue:**

```javascript
return {
   decision: { 
     status: 'continue', 
     message: 'Payload is valid, proceed to submit request', 
   }
};
```

**Next:**

```javascript
return {
   decision: { 
     status: 'next', 
     message: 'Asset already exists. Move to create vulnerability', 
   }
};
```

**Repeat:**

```javascript
return {
   decision: { 
     status: 'repeat', 
     message: 'Processed vulnerability, proceed to next vuln'
   }
};
```

**Abort:**

```javascript
return {
   decision: { 
     status: 'abort', 
     message: 'Auth token not generated. Check if credentials are valid?', 
   }
};
```

**Finish:**

```javascript
return {
   decision: { 
     status: 'finish', 
     message: 'Vulnerability created!', 
   }
};
```

#### **Request**

In a Request Script, return `request` to change the request. Each field is optional. Any field you leave out uses the Action's setting.

| Field     | Description                     |
| --------- | ------------------------------- |
| `url`     | Where the request is sent       |
| `body`    | The request body                |
| `headers` | The request headers             |
| `method`  | GET, POST, PUT, PATCH or DELETE |

```javascript
return {
   decision: { 
     status: 'continue', 
     message: 'Payload is valid, proceed to submit request', 
   }, 
   request: { 
     url: 'https://www.attackforge.com/api',
     body: {}, 
     headers: {}, 
     method: 'GET', 
   }
};
```

**Body:**

```javascript
return {
    decision: { 
        status: 'continue'
    },
    request: {
        body: {
            fields: {
                project: {
                    key: jiraProjectKey
                },
                summary: summary,
                description: description,
                priority: {
                    name: priority
                },
                issuetype: {
                    name: 'Bug'
                },
                labels: labels
            }
        }
    }
};
```

**Headers:**

```javascript
return {
    decision: { 
        status: 'continue',
    },
    request: {
        headers: {
            'Content-Type': 'application/json',
            'x-ssapi-key': secrets.af_auth,
        }
    }
};
```

**Method:**

```javascript
return {
    decision: { 
        status: 'continue',
    },
    request: {
        method: 'GET' // supports GET, POST, PUT, PATCH, DELETE
    }
};
```

#### **Summary**

Return a `summary` from an action, request or response script and it appears right where the run is reported, so the person who clicked the button knows what happened.

```javascript
const link = 'https://acmecorp.atlassian.net/browse/AFVULN-3148';

return {
  decision: {
    status: 'finish',
    message: 'JIRA Issue created',
  },
  summary: `JIRA Ticket Created - See ${link}`
};
```

Example when user runs the action - notice the notification next to *Completed*:

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FNwhXFzHUUU0Ij8OkJOpR%2FScreenshot%202026-11-14%20at%209.05.16%E2%80%AFam.png?alt=media&amp;token=412f6fab-4bac-4826-89d4-f26af2d5a425" alt=""><figcaption></figcaption></figure>

Clicking on the notification shows the user the summary message:

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FXsyTKRCMYCAZVuUVPyEx%2FScreenshot%202026-11-14%20at%209.05.27%E2%80%AFam.png?alt=media&amp;token=941a6667-a8bd-40e8-8177-ae651e597c42" alt=""><figcaption></figcaption></figure>

#### **Data**

Return `data` to pass values from the Request Script to the Response Script, and from the Response Script to the next Action.

In a Request Script:

```javascript
return {
    decision: { 
        status: 'continue',
    },
    data: {
        af_project_id: afProjectId,
        af_vuln: data
    }
};
```

In a Response Script, passing the values on:

```javascript
return {
    decision: { 
        status: 'continue',
    },
    data: {
        af_project_id: data.af_project_id,
        af_vuln: data.af_vuln
    }
};
```

## Secrets

Secrets store sensitive values, such as passwords and API keys. They're encrypted. Flow Secrets are visible only to users with access to the Flow.

You can also reference your [User Secrets](https://support.attackforge.com/attackforge-enterprise/getting-started/manage-user#secrets). Because several Flows can use the same User Secret, you rotate it in one place.

### Add a secret

1. Click **Secrets**.
2. Click **Add Secret**.
3. Create a **Local Secret**, or select one of your **User Secrets**. Keys can contain letters, numbers and underscores.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fh1DKD4LDDQDXXcXRoMpq%2FScreenshot%202026-11-11%20at%209.26.37%E2%80%AFam.png?alt=media&amp;token=518eeb08-5e82-4473-a7a1-67454699a4bc" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FEi9FMnfXIoJv3BDvtEwb%2FScreenshot%202026-11-11%20at%209.26.31%E2%80%AFam.png?alt=media&amp;token=f021293d-b581-4195-99fa-44aa4153a9f2" alt=""><figcaption></figcaption></figure>

#### Use secrets in headers

Set the header's type to **Secret**, then choose an existing secret or create one.

#### Use secrets in Request and Response Scripts

Select **Use Secrets** for the script, then reference the secret as:

```javascript
secrets.<KEY>
```

## Download and upload files

### Download files

In the Action's **Options**, select **Download Response**. The response then includes a `fileId`, which later Actions can use.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2F2L0VsS01FCN0Py67M4tO%2FScreenshot%202026-11-11%20at%209.28.42%E2%80%AFam.png?alt=media&amp;token=ccbff2d7-f6b2-4b81-b9bb-ffb4a2f7c1fa" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FEOzaxB3SAi4592XYLwvb%2FScreenshot%202026-11-11%20at%209.29.20%E2%80%AFam.png?alt=media&amp;token=ce9ec7c2-73dd-4075-87a8-c6cebfca828a" alt=""><figcaption></figcaption></figure>

### Upload files

Upload a file you downloaded earlier by its `fileId`, using a `multipart/form-data` request. For example, attach a file from an external system to a vulnerability, or upload a generated report to a project.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fa0mV18MN10MFcrXzGhH1%2FScreenshot%202026-11-11%20at%209.30.36%E2%80%AFam.png?alt=media&amp;token=e0014726-5d97-451a-82a5-e856a40b398f" alt=""><figcaption></figcaption></figure>

## Runs

A Run is one execution of a Flow, from its trigger to its finish. Each Run has a status, a start time, a duration and the Actions it took.

{% hint style="info" %}
**Important:** Normal runs execute as the Flow Owner, and only for records the owner can access. Test runs can use test data at any time.
{% endhint %}

See every Run you can access in the Flows module, or the Runs for one Flow by clicking its name.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FrKnhyX9rueUKaNSPnRhN%2FScreenshot%202026-11-11%20at%209.32.11%E2%80%AFam.png?alt=media&amp;token=4653ddb5-4958-4590-a670-4682099fb4f3" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FVjPPcCI2u6ExbflNGeDS%2FScreenshot%202026-11-11%20at%209.32.48%E2%80%AFam.png?alt=media&amp;token=ffb02aa7-3f3b-4ed6-b4e4-88b302d14afd" alt=""><figcaption></figcaption></figure>

### Run statuses

| Status         | Meaning                                      |
| -------------- | -------------------------------------------- |
| **Running**    | The Run is in progress.                      |
| **Completed**  | The Run finished successfully.               |
| **Failed**     | The Run ended with an error.                 |
| **Dropped**    | The Run was a duplicate, so it didn't run.   |
| **Missed**     | The Run didn't happen at its scheduled time. |
| **Terminated** | Someone stopped the Run manually.            |

### Run logs

Run logs show:

* **Run status:** Completed or Failed
* **Event:** what triggered the Run
* **Started** and **Duration** (in milliseconds)
* **Actions:** each Action in the Run
* **Data:** the input and output Data for each Action
* **HTTP:** the URL, method, headers, body, status code and response body
* **Logs:** messages from your scripts

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fhbz2W9xbnvJWQxH7xNds%2FScreenshot%202026-11-11%20at%209.34.25%E2%80%AFam.png?alt=media&amp;token=64c53fe7-3ac7-4d6a-a753-d8920bfd4cf1" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FZAD1A3hu65soKQfQFTIt%2FScreenshot%202026-11-11%20at%209.34.33%E2%80%AFam.png?alt=media&amp;token=b049c482-126e-4f69-8377-99e835a0e214" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fnha4SyG9GTEfyhsvNyOH%2FScreenshot%202026-11-11%20at%209.34.41%E2%80%AFam.png?alt=media&amp;token=035534e9-869f-4b0f-8301-fa57313bfeab" alt=""><figcaption></figcaption></figure>

### Run a Flow manually

Run a Flow on demand, with test data you can edit for the first Action. Use it to test a Flow before you enable it.

### Re-run a Flow

Re-run a Flow with exactly the same input as a previous Run. The Event shows that it was re-run.

### Get the result of an HTTP-triggered Run

HTTP-triggered Flows run asynchronously. The trigger returns a **Flow Run Id**. Use it to get the Run's result:

```bash
curl --request GET \
	--url 'https://{{tenant}}/api/flows/runs/{{flowRunId}}' \
	--header 'x-user-key: {{api-key}}'
```

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FAp0YF1kiMrxfeSGOIvaX%2FScreenshot%202025-11-14%20at%204.31.06%E2%80%AFpm.png?alt=media&amp;token=b6503bfd-af1c-4663-992a-e60f6912a22c" alt=""><figcaption></figcaption></figure>

Add `?format=html` for a page you can open in a browser. The example below is an *unauthenticated request*.

```bash
curl --request GET \
	--url 'https://{{tenant}}/api/flows/runs/{{flowRunId}}?format=html'
```

A `successful` response will appear as follows:

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FizOI4NBDSXZjZAXMWNtG%2Fsuccess.png?alt=media&amp;token=56343e1c-ad9d-4d8a-bc8e-c82365aeb347" alt=""><figcaption></figcaption></figure>

A `failed` response will appear as follows:

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FWtyTRmUAK1MLHqKk3yaQ%2Ffailed.png?alt=media&amp;token=b39b42ca-f423-4d47-b52e-85b690b7674a" alt=""><figcaption></figcaption></figure>

## Share Flows with your team

Each Flow belongs to the user who created it, the **Flow Owner**. A Flow always runs as one user, its owner. You can transfer ownership (see "Transfer a Flow"). Only owners can share a Flow.

To share a Flow:

1. Open the Flow's **Settings**.
2. Click **Add Access**.
3. Choose who to share with. Administrators can choose Roles, Groups or Users. Other users can choose Groups they belong to, or Users by email.
4. Choose the **Access Level** and **Trigger Access**.
5. Click **Add** to save.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FfMlsU5QgvSq1k3Cvb8vq%2FScreenshot%202026-11-11%20at%209.41.17%E2%80%AFam.png?alt=media&amp;token=7ee34c79-1654-46d8-9e1c-ada1da3b466f" alt=""><figcaption></figcaption></figure>

### Access levels

| Level    | Can                                                                                                                                   |
| -------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| **None** | Nothing                                                                                                                               |
| **Info** | See the name, status, last run, trigger, whether it's enabled, owner and readme, and for HTTP triggers the method, URL and trigger ID |
| **View** | Everything in Info, plus all runs, actions, run details and logs, and export                                                          |
| **Edit** | Everything in View, plus edit, Save and Run, and disable the Flow                                                                     |

### Trigger access

Trigger access controls who can start the Flow through an authenticated HTTP trigger, using their User Key in the nominated header.

| Option             | Can                                                                                                                                                         |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **No**             | Not trigger the Flow                                                                                                                                        |
| **Yes**            | Trigger the Flow with a valid User Key                                                                                                                      |
| **Yes + Delegate** | Trigger the Flow, and also link it to their own [Actions](https://support.attackforge.com/app/automations-and-integrations/actions) and share those Actions |

### Override

Select **Override** to make sure a user gets exactly the access you assign, even if they'd get different access through a Role or Group. Click **Add** to save.

{% hint style="info" %}
**Note:** Administrators can view all Flows.
{% endhint %}

### Effective access

Owners can see who has access to a Flow, from Roles, Groups and Users combined, under **Flow settings > Effective Access**.

## Manage Flows

### Flow readme

Each Flow can have a readme. Use it to explain how the Flow works and how to run it, and to link to external documentation and contacts.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FE73R1XiJI0wxbpDgaGGX%2FScreenshot%202026-11-11%20at%209.47.06%E2%80%AFam.png?alt=media&amp;token=514edfd6-3919-4188-92cd-7d7637e1b29a" alt=""><figcaption></figcaption></figure>

### Import and export Flows

Click **Export Flow** to save a Flow as a `.flow` file. Use it to share a Flow, back it up, or use it as a template. Secret values aren't exported, but their key names are.

Click **Import Flow** to import a `.flow` file. Review it, add any secret values, then save.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fpm10so1f8nipTD7LX1I2%2FScreenshot%202026-11-11%20at%209.54.33%E2%80%AFam.png?alt=media&amp;token=2837cb8e-a73c-4352-9a4c-5cc15fcff057" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FNiAGvt2Dh3hPHguEeVco%2FScreenshot%202026-11-11%20at%209.54.42%E2%80%AFam.png?alt=media&amp;token=75aa1f9d-30ed-4840-afdf-90bc4c184f46" alt=""><figcaption></figcaption></figure>

## Transfer a Flow

Because a Flow runs as its owner, you may need to transfer it, for example when someone leaves the team.

1. Open **Flow settings > Transfer**.
2. Select a user, or enter their email.

The new owner receives the Flow disabled. It runs again once they enable it.

## Tips

* **Test before you enable.** Use Manually Run Flow with test data, then check the Run logs.
* **Log as you build.** Use `Logger.debug` to see Data and Response objects at each step.
* **Keep credentials in secrets.** Never put API keys in scripts. Use User Secrets for keys shared across Flows, so you rotate them once.
* **Use authenticated HTTP triggers** where you can. If a trigger is non-authenticated, protect its URL and regenerate it if it leaks.
* **Redact sensitive headers** in Trigger configuration, so they don't appear in run logs.
* **Use a service account as the Flow Owner** for team Flows, so they keep running when people change roles. See [Working with Service Accounts](https://support.attackforge.com/app/automations-and-integrations/working-with-service-accounts).
* **Write a readme** for every shared Flow: what it does, who owns it and how to fix it.
* **Export Flows** before big changes, as a backup.

## FAQ

**Which plans include Flows?** Enterprise and the Core SME plan. Other plans can add it from Administration > Subscriptions.

**Why can't I create a Flow?** You need Create access to at least one trigger type. Ask an administrator to set it under Users > (select user) > Access > Flows.

**Can a Flow have more than one trigger?** No. A Flow has one trigger.

**Whose access does a Flow use?** The Flow Owner's. Runs only cover records the owner can access.

**What happens to my Flows if I leave?** Transfer them to someone else. The new owner receives them disabled until they enable them.

**How do I see why a Run failed?** Open the Run's logs. They show each Action's Data, HTTP details and script logs.

**How do I get the result of an HTTP-triggered Flow?** Use the Flow Run Id it returns with the runs API. See "Get the result of an HTTP-triggered Run".

**Are secrets included when I export a Flow?** No. Secret key names are included, but not their values.

**What language are scripts written in?** [AFScript](https://support.attackforge.com/app/automations-and-integrations/afscript).

**How long can a delay be?** Up to 86400000 milliseconds (24 hours).

## Related pages

* [Actions](https://support.attackforge.com/app/automations-and-integrations/actions)
* [AFScript](https://support.attackforge.com/app/automations-and-integrations/afscript)
* [Self-Service Events API](https://support.attackforge.com/app/automations-and-integrations/self-service-events-api)
* [Self-Service RESTful API](https://support.attackforge.com/app/automations-and-integrations/self-service-restful-api)
* [Working with Service Accounts](https://support.attackforge.com/app/automations-and-integrations/working-with-service-accounts)
* [AI MCP and Skills](https://support.attackforge.com/app/automations-and-integrations/ai-mcp-and-skills)
* [Report Automation](https://support.attackforge.com/app/automations-and-integrations/report-automation)
* Integration guides: [Jira](https://support.attackforge.com/app/automations-and-integrations/flows/atlassian-jira), [ServiceNow](https://support.attackforge.com/app/automations-and-integrations/flows/servicenow), [Azure DevOps](https://support.attackforge.com/app/automations-and-integrations/flows/azure-devops-ado), [Flashpoint](https://support.attackforge.com/app/automations-and-integrations/flows/flashpoint-vulndb), [HackerOne](https://support.attackforge.com/app/automations-and-integrations/flows/hackerone), [Bugcrowd](https://support.attackforge.com/app/automations-and-integrations/flows/bugcrowd), [Tenable](https://support.attackforge.com/app/automations-and-integrations/flows/tenable), [Qualys](https://support.attackforge.com/app/automations-and-integrations/flows/qualys), [Slack](https://support.attackforge.com/app/automations-and-integrations/flows/slack), [Microsoft Teams](https://support.attackforge.com/app/automations-and-integrations/flows/microsoft-teams), [Power BI](https://support.attackforge.com/app/automations-and-integrations/flows/microsoft-powerbi), [Salesforce](https://support.attackforge.com/app/automations-and-integrations/flows/salesforce), [Synack](https://support.attackforge.com/app/automations-and-integrations/flows/synack), [Wiz](https://support.attackforge.com/app/automations-and-integrations/flows/wiz), [Webhook](https://support.attackforge.com/app/automations-and-integrations/flows/webhook), [Custom Emails](https://support.attackforge.com/app/automations-and-integrations/flows/custom-emails)


---

# 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://support.attackforge.com/app/automations-and-integrations/flows.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.
