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.

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

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));

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}')

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();
        }
    }
}

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))
  }
}

#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)

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

Processes > Archive process

Tallyfy’s API lets you soft-delete (archive) a running process via a DELETE request so it disappears from default views while preserving all tasks and data intact and can be fully restored later using the activate endpoint.

Code Samples > Managing processes (Runs)

The Tallyfy API manages processes (called “runs”) through org-scoped endpoints that cover launching from templates or as empty containers and listing and filtering and fetching details and updating and archiving and restoring and permanently deleting processes along with retrieving activity feeds for audit trails.

Templates > Archive or delete template

Tallyfy’s API supports removing templates through a two-step process: first archiving (soft delete) via a DELETE request to the checklist endpoint which hides the template while preserving data and allowing restoration and then permanently deleting it via a second DELETE request with an extra /delete path segment which irreversibly removes all associated data and requires admin permissions.

Tasks > Archive task

Tallyfy’s API lets you soft-delete (archive) a standalone one-off task by sending a DELETE request to /organizations/[org_id]/tasks/[task_id] which hides it from default views while preserving all data and allowing restoration later through a separate restore endpoint.

Was this helpful?

Get in touch

About Tallyfy