Delete process

Administrators only

Endpoint

Section titled “Endpoint”

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

This permanently deletes an archived process (run). All its related data goes too. That means its tasks, comments, form field values, attachments, tags and watchers.

Irreversible action

This can’t be undone. All data tied to this run is removed from the database for good. Not sure? Archive the process and leave it archived.

Must be archived first

You can only do this to a process that’s already archived (soft-deleted). If you call this on an active process, you’ll get an error. Archive it first with DELETE /organizations/{org_id}/runs/{run_id}.

Request

Section titled “Request”

Replace {org_id} with your organization ID. Replace {run_id} with the ID of the run to delete.

Headers

Section titled “Headers”

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

Body

Section titled “Body”

You don’t need a request body.

Code samples

Section titled “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

Section titled “Response”

You’ll get 200 OK. The response body is empty. The process and all its related data are gone for good.

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

Section titled “Related articles”

Processes > Archive process

Tallyfy’s API lets you soft-delete (archive) a running process via a DELETE request. The process…

Code Samples > Managing processes (runs)

Use the Tallyfy API to manage processes (runs) through org-scoped endpoints. Launch, list…

Tags > Delete tag

Tallyfy’s DELETE API endpoint at /organizations/[org_id]/tags/[tag_id] permanently removes a…

Tasks > Archive task

Tallyfy’s API lets you soft-delete (archive) a standalone one-off task by sending a DELETE…

Was this helpful?

YesNo