Activate process

Endpoint

PUT /organizations/{org_id}/runs/{run_id}/activate

This endpoint restores a previously archived process (called a “run” in the API). Once restored, the run’s archived_at field becomes null and it reappears in default views.

Request

Replace {org_id} with your Organization ID and {run_id} with the run ID you want to restore.

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_ACTIVATE';
const apiUrl = `https://go.tallyfy.com/api/organizations/${orgId}/runs/${runId}/activate`;

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

fetch(apiUrl, {
    method: 'PUT',
    headers: headers
})
.then(response => {
    return response.json().then(data => {
        if (!response.ok) {
            console.error(`Failed to activate process ${runId}:`, data);
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        console.log(`Activated process ${runId}. Status: ${response.status}`);
        return data;
    });
})
.then(data => {
    console.log('Activated process details:');
    console.log(JSON.stringify(data, null, 2));
})
.catch(error => {
    console.error(`Error activating process ${runId}:`, error.message);
});

import requests
import json
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_ACTIVATE'
api_url = f'https://go.tallyfy.com/api/organizations/{org_id}/runs/{run_id}/activate'

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

response = requests.put(api_url, headers=headers)

if response.status_code == 200:
    print(f'Activated process {run_id}.')
    print(json.dumps(response.json(), indent=4))
else:
    print(f'Error activating process {run_id}: {response.status_code}')
    print(response.text)

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 ActivateProcess {
    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_ACTIVATE";
        String apiUrl = String.format(
            "https://go.tallyfy.com/api/organizations/%s/runs/%s/activate", 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")
                .PUT(HttpRequest.BodyPublishers.noBody())
                .build();

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

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

package main

import (
  "bytes"
  "encoding/json"
  "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_ACTIVATE"
  apiUrl := fmt.Sprintf("https://go.tallyfy.com/api/organizations/%s/runs/%s/activate", orgId, runId)

  client := &http.Client{Timeout: 15 * time.Second}
  req, err := http.NewRequest(http.MethodPut, 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, err := io.ReadAll(resp.Body)
  if err != nil {
    fmt.Printf("Error reading response: %v\n", err)
    return
  }

  if resp.StatusCode == http.StatusOK {
    fmt.Printf("Activated process %s\n", runId)
    var prettyJSON bytes.Buffer
    if err := json.Indent(&prettyJSON, body, "", "  "); err == nil {
      fmt.Println(prettyJSON.String())
    } else {
      fmt.Println(string(body))
    }
  } else {
    fmt.Printf("Error %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> ActivateTallyfyProcess(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("/activate");

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

    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)
    {
        utility::string_t runIdW = runId;
        return response.extract_json().then([response, runIdW](pplx::task<json::value> task)
        {
            try {
                json::value const & body = task.get();
                if (response.status_code() == status_codes::OK) {
                    std::wcout << L"Activated process " << runIdW
                               << L"\n" << body.serialize() << std::endl;
                } else {
                    std::wcerr << L"Error " << response.status_code()
                               << L": " << body.serialize() << std::endl;
                }
            } catch (const std::exception& e) {
                std::wcerr << L"Exception: " << e.what() << std::endl;
            }
        });
    });
}

int main() {
    try {
        ActivateTallyfyProcess(U("PROCESS_RUN_ID_TO_ACTIVATE")).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;
using System.Text.Json;

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

    public static async Task ActivateProcessAsync(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}/activate";

        using var request = new HttpRequestMessage(HttpMethod.Put, 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($"Activated process {runId}");
            using var doc = JsonDocument.Parse(responseBody);
            Console.WriteLine(JsonSerializer.Serialize(doc.RootElement,
                new JsonSerializerOptions { WriteIndented = true }));
        }
        else
        {
            Console.WriteLine($"Error {response.StatusCode}: {responseBody}");
        }
    }

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

Response

A successful request returns 200 OK with the restored run wrapped in a data object. The archived_at field will be null, and status retains whatever value it had before archiving (e.g., active, complete, or problem).

{
  "data": {
    "id": "PROCESS_RUN_ID_TO_ACTIVATE",
    "checklist_id": "template_id_here",
    "name": "Restored Project Run",
    "status": "active",
    "archived_at": null,
    "started_at": "2025-01-15T10:00:00.000Z",
    "last_updated": "2025-06-20T14:30:00.000Z"
  }
}

If the run ID isn’t found or you don’t have access, you’ll get a 404 or 403 error.

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.

Processes > Delete process

Tallyfy’s API lets admins permanently and irreversibly delete an already-archived process run along with all its associated tasks and data by sending a DELETE request to the /runs/[run_id]/delete endpoint with code samples provided in six languages.

Processes > List processes

Tallyfy’s API lets you retrieve a paginated and filterable list of all running process instances in your organization by calling GET on the runs endpoint with optional parameters for status and ownership and tags and sorting and related data inclusion.

Was this helpful?

Get in touch

About Tallyfy