Re-execute a flow execution

curl --request POST \
  --url https://flows.super.ai/api/flow-executions/{flow_execution_id}/execute \
  --header 'Authorization: Bearer <token>'

import requests

url = "https://flows.super.ai/api/flow-executions/{flow_execution_id}/execute"

headers = {"Authorization": "Bearer <token>"}

response = requests.post(url, headers=headers)

print(response.text)

const options = {method: 'POST', headers: {Authorization: 'Bearer <token>'}};

fetch('https://flows.super.ai/api/flow-executions/{flow_execution_id}/execute', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://flows.super.ai/api/flow-executions/{flow_execution_id}/execute",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://flows.super.ai/api/flow-executions/{flow_execution_id}/execute"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://flows.super.ai/api/flow-executions/{flow_execution_id}/execute")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

flow-executions

Re-execute a flow execution

Re-execute a flow execution, optionally skipping cached results.

This endpoint triggers re-execution of an existing flow execution. It can selectively re-run failed tasks or re-run the entire flow from scratch. Useful for retrying failed executions or refreshing stale data.

Asynchronous. A 202 means the re-run has been accepted and durably recorded, not that it has happened. Resetting the task state and starting the new run take a few seconds, and both survive a restart on our side. Do not assume the execution’s tasks have been reset when this returns — watch the flow execution (the Location header) or subscribe to its WebSocket events, and act when its status reaches queued/running.

Context:

Re-executes workflows that have completed or failed
Can reuse successful task results (cached execution)
Useful for handling transient failures
Updates flow to latest version if changed since original execution
Creates new workflow instance with same execution ID
A repeat request while one is still in progress is folded into it rather than starting a competing re-run

Execution Modes:

Full Re-execution (only_stale=false, default):
- Starts workflow from beginning
- All tasks execute regardless of previous state
- Previous results are discarded
- Use for: Complete retry after fixing flow definition
Stale-Only Re-execution (only_stale=true):
- Only re-runs tasks marked as ‘stale’
- Reuses results from successful tasks
- Faster for partial failures
- Use for: Refreshing outdated data without full re-run

Behavior:

Terminates existing workflow if still running
Updates flow_version to latest version
Maintains same execution ID for traceability
Status transitions: any → queued → running (or → failed if the re-run could not be completed, which is distinct from the flow itself failing)
Does not create new execution record

Performance Notes:

Response time: < 200ms (the request only validates and schedules)
The reset and the new run land within seconds of the response
Stale-only mode significantly faster for large flows
Full re-execution recalculates all task outputs

Use Cases:

Retry failed execution after fixing flow definition
Refresh data after external system updates
Resume execution after transient service outage
Update execution to use latest flow version

Related Endpoints:

GET /flow-executions/ - Check re-execution status
POST /flow-executions - Create new execution instead of re-running

POST

api

flow-executions

{flow_execution_id}

execute

Re-execute a flow execution

curl --request POST \
  --url https://flows.super.ai/api/flow-executions/{flow_execution_id}/execute \
  --header 'Authorization: Bearer <token>'

import requests

url = "https://flows.super.ai/api/flow-executions/{flow_execution_id}/execute"

headers = {"Authorization": "Bearer <token>"}

response = requests.post(url, headers=headers)

print(response.text)

const options = {method: 'POST', headers: {Authorization: 'Bearer <token>'}};

fetch('https://flows.super.ai/api/flow-executions/{flow_execution_id}/execute', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://flows.super.ai/api/flow-executions/{flow_execution_id}/execute",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://flows.super.ai/api/flow-executions/{flow_execution_id}/execute"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://flows.super.ai/api/flow-executions/{flow_execution_id}/execute")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

Authorizations

Authorization

string

header

required

JWT Bearer token authentication. Include your access token in the Authorization header as: Bearer YOUR_ACCESS_TOKEN

Example:

Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

Path Parameters

flow_execution_id

string<uuid>

required

UUID of the flow execution to re-execute. Must be an existing execution owned by your organization.

Query Parameters

only_stale

boolean

default:false

If true, only re-executes tasks marked as 'stale'. If false (default), re-executes entire flow from beginning. Stale-only mode is faster for flows with many successful tasks.

Response

Re-execution accepted and durably recorded. The work happens asynchronously: task state is reset and a new run is started within seconds. The Location header points at the flow execution, whose status is the monitor for this operation — it moves to queued, then running, or to failed if the re-run could not be completed.