Delete process

Endpoint

DELETE /organizations/{org_id}/runs/{run_id}/delete

Permanently deletes an archived process (run) and all its related data — tasks, comments, form field values, attachments, tags, and watchers.

Irreversible action

This can’t be undone. All data tied to this run is permanently removed from the database. If you’re unsure, archive the process first and leave it archived.

Must be archived first

You can only permanently delete a process that’s already been archived (soft-deleted). Calling this on an active process returns an error. Archive it first using DELETE /organizations/{org_id}/runs/{run_id}.

Admin only

This endpoint requires the admin role. Non-admin members will get a 403 Forbidden response.

Request

Replace {org_id} with your Organization ID and {run_id} with the run ID to delete.

Headers

• Authorization: Bearer {your_access_token}
• Accept: application/json
• X-Tallyfy-Client: APIClient

Body

No request body is needed.

Code samples

Javascript

const accessToken = 'YOUR_PERSONAL_ACCESS_TOKEN';
const orgId = 'YOUR_ORGANIZATION_ID';
const runId = 'PROCESS_RUN_ID_TO_DELETE';
const apiUrl = `https://go.tallyfy.com/api/organizations/${orgId}/runs/${runId}/delete`;

const headers = new Headers();
headers.append('Authorization', `Bearer ${accessToken}`);
headers.append('Accept', 'application/json');
headers.append('X-Tallyfy-Client', 'APIClient');

fetch(apiUrl, {
    method: 'DELETE',
    headers: headers
})
.then(response => {
    if (response.ok) {
        console.log(`Permanently deleted process ${runId}. Status: ${response.status}`);
        return response.text().then(text => {
            if (text) {
                try { return JSON.parse(text); }
                catch (e) { return null; }
            }
            return null;
        });
    } else {
        return response.json()
            .catch(() => response.text())
            .then(errData => {
                console.error(`Failed (${response.status}):`, errData);
                throw new Error(`HTTP error ${response.status}`);
            });
    }
})
.then(data => {
    if (data) console.log(JSON.stringify(data, null, 2));
})
.catch(error => console.error('Delete failed:', error.message));

Python

import requests
import os

access_token = os.environ.get('TALLYFY_ACCESS_TOKEN', 'YOUR_PERSONAL_ACCESS_TOKEN')
org_id = os.environ.get('TALLYFY_ORG_ID', 'YOUR_ORGANIZATION_ID')
run_id = 'PROCESS_RUN_ID_TO_DELETE'
api_url = f'https://go.tallyfy.com/api/organizations/{org_id}/runs/{run_id}/delete'

headers = {
    'Authorization': f'Bearer {access_token}',
    'Accept': 'application/json',
    'X-Tallyfy-Client': 'APIClient'
}

try:
    response = requests.delete(api_url, headers=headers)
    response.raise_for_status()
    print(f'Permanently deleted process {run_id}. Status: {response.status_code}')
except requests.exceptions.HTTPError as e:
    print(f'HTTP error deleting process {run_id}: {e}')
    print(f'Response: {e.response.text}')
except requests.exceptions.RequestException as e:
    print(f'Request failed: {e}')

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.io.IOException;

public class DeleteProcess {
    public static void main(String[] args) {
        String accessToken = System.getenv().getOrDefault("TALLYFY_ACCESS_TOKEN", "YOUR_PERSONAL_ACCESS_TOKEN");
        String orgId = System.getenv().getOrDefault("TALLYFY_ORG_ID", "YOUR_ORGANIZATION_ID");
        String runId = "PROCESS_RUN_ID_TO_DELETE";
        String apiUrl = String.format(
            "https://go.tallyfy.com/api/organizations/%s/runs/%s/delete", orgId, runId);

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(apiUrl))
                .header("Authorization", "Bearer " + accessToken)
                .header("Accept", "application/json")
                .header("X-Tallyfy-Client", "APIClient")
                .DELETE()
                .build();

        try {
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

            if (response.statusCode() == 200) {
                System.out.println("Permanently deleted process " + runId);
            } else {
                System.err.println("Failed (" + response.statusCode() + "): " + response.body());
            }
        } catch (IOException | InterruptedException e) {
            System.err.println("Request failed: " + e.getMessage());
            Thread.currentThread().interrupt();
        }
    }
}

Go

package main

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

func main() {
  accessToken := os.Getenv("TALLYFY_ACCESS_TOKEN")
  if accessToken == "" { accessToken = "YOUR_PERSONAL_ACCESS_TOKEN" }
  orgId := os.Getenv("TALLYFY_ORG_ID")
  if orgId == "" { orgId = "YOUR_ORGANIZATION_ID" }
  runId := "PROCESS_RUN_ID_TO_DELETE"
  apiUrl := fmt.Sprintf("https://go.tallyfy.com/api/organizations/%s/runs/%s/delete", orgId, runId)

  client := &http.Client{Timeout: 15 * time.Second}
  req, err := http.NewRequest(http.MethodDelete, apiUrl, nil)
  if err != nil {
    fmt.Printf("Error creating request: %v\n", err)
    return
  }

  req.Header.Set("Authorization", "Bearer "+accessToken)
  req.Header.Set("Accept", "application/json")
  req.Header.Set("X-Tallyfy-Client", "APIClient")

  resp, err := client.Do(req)
  if err != nil {
    fmt.Printf("Error executing request: %v\n", err)
    return
  }
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)

  if resp.StatusCode == http.StatusOK {
    fmt.Printf("Permanently deleted process %s\n", runId)
    if len(body) > 0 {
      fmt.Println(string(body))
    }
  } else {
    fmt.Printf("Failed (%d): %s\n", resp.StatusCode, string(body))
  }
}

C++

#include <iostream>
#include <string>
#include <cpprest/http_client.h>
#include <cpprest/json.h>

using namespace web;
using namespace web::http;
using namespace web::http::client;

pplx::task<void> DeleteTallyfyProcess(const utility::string_t& runId)
{
    utility::string_t accessToken = U("YOUR_PERSONAL_ACCESS_TOKEN");
    utility::string_t orgId = U("YOUR_ORGANIZATION_ID");
    utility::string_t apiUrl = U("https://go.tallyfy.com/api/organizations/") + orgId
        + U("/runs/") + runId + U("/delete");

    http_client client(apiUrl);
    http_request request(methods::DEL);

    request.headers().add(U("Authorization"), U("Bearer ") + accessToken);
    request.headers().add(U("Accept"), U("application/json"));
    request.headers().add(U("X-Tallyfy-Client"), U("APIClient"));

    return client.request(request).then([runId](http_response response)
    {
        status_code status = response.status_code();
        return response.extract_string().then([status, runId](utility::string_t body)
        {
            if (status == status_codes::OK) {
                std::wcout << L"Permanently deleted process " << runId << std::endl;
            } else {
                std::wcerr << L"Failed (" << status << L"): " << body << std::endl;
                throw std::runtime_error("Failed to delete process");
            }
        });
    });
}

int main() {
    try {
        DeleteTallyfyProcess(U("PROCESS_RUN_ID_TO_DELETE")).wait();
    } catch (const std::exception &e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    return 0;
}
// Requires C++ REST SDK (Casablanca)

C#

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;

public class TallyfyProcessDeleter
{
    private static readonly HttpClient client = new HttpClient();

    public static async Task DeleteProcessAsync(string runId)
    {
        var accessToken = Environment.GetEnvironmentVariable("TALLYFY_ACCESS_TOKEN")
            ?? "YOUR_PERSONAL_ACCESS_TOKEN";
        var orgId = Environment.GetEnvironmentVariable("TALLYFY_ORG_ID")
            ?? "YOUR_ORGANIZATION_ID";
        var apiUrl = $"https://go.tallyfy.com/api/organizations/{orgId}/runs/{runId}/delete";

        try
        {
            using var request = new HttpRequestMessage(HttpMethod.Delete, apiUrl);
            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            request.Headers.Add("X-Tallyfy-Client", "APIClient");

            HttpResponseMessage response = await client.SendAsync(request);
            string responseBody = await response.Content.ReadAsStringAsync();

            if (response.IsSuccessStatusCode)
            {
                Console.WriteLine($"Permanently deleted process {runId}");
            }
            else
            {
                Console.WriteLine($"Failed ({response.StatusCode}): {responseBody}");
            }
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"Request failed: {e.Message}");
        }
    }

    // static async Task Main(string[] args)
    // {
    //     await DeleteProcessAsync("PROCESS_RUN_ID_TO_DELETE");
    // }
}

Response

A successful permanent deletion returns 200 OK with an empty response body. The process and all related data have been permanently removed.

Status	Meaning
200	Process permanently deleted
403	You don’t have admin role permissions
404	Process not found (wrong ID or not archived)
422	Process isn’t archived yet — archive it first

---

Related articles

Processes > Archive process

Archive a Tallyfy process (run) using a DELETE request, which soft-deletes it from default views while preserving all data for future restoration.

Code Samples > Managing processes (Runs)

Use the Tallyfy API to launch, list, update, archive, restore, and permanently delete processes (runs) - the live instances created from your templates.

Tasks > Delete task

A DELETE endpoint permanently removes standalone tasks while preserving process-related tasks that can only be deleted through their parent process run deletion.

Tags > Delete tag

Permanently deletes a tag and all its associations from your organization. This can’t be undone - the API returns 204 No Content on success.

Was this helpful?

YesNo