Delete tag

Endpoint

DELETE /organizations/{org_id}/tags/{tag_id}

This permanently deletes a tag and removes all its associations with templates, processes, steps, and tasks. This action can’t be undone.

Request

Replace {org_id} with your Organization ID and {tag_id} with the tag’s ID.

Headers

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

Body

You don’t need a request body.

Code samples

const accessToken = 'YOUR_PERSONAL_ACCESS_TOKEN';
const orgId = 'YOUR_ORGANIZATION_ID';
const tagId = 'TAG_ID_TO_DELETE';
const apiUrl = `https://go.tallyfy.com/api/organizations/${orgId}/tags/${tagId}`;

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.status === 204) {
        console.log(`Tag ${tagId} deleted permanently.`);
    } else if (!response.ok) {
        return response.json().then(errData => {
            console.error(`Failed to delete tag ${tagId}:`, errData);
            throw new Error(`HTTP error! status: ${response.status}`);
        });
    }
})
.catch(error => {
    console.error(`Error deleting tag ${tagId}:`, 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')
tag_id = 'TAG_ID_TO_DELETE'
api_url = f'https://go.tallyfy.com/api/organizations/{org_id}/tags/{tag_id}'

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

response = None
try:
    response = requests.delete(api_url, headers=headers)
    response.raise_for_status()

    if response.status_code == 204:
        print(f'Tag {tag_id} deleted permanently.')
    else:
        print(f'Unexpected status: {response.status_code}')

except requests.exceptions.HTTPError as http_err:
    print(f"HTTP error deleting tag {tag_id}: {http_err}")
    if response is not None:
        print(f"Response Body: {response.text}")
except requests.exceptions.RequestException as req_err:
    print(f"Request failed deleting tag {tag_id}: {req_err}")

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 DeleteTag {
    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 tagId = "TAG_ID_TO_DELETE";
        String apiUrl = String.format("https://go.tallyfy.com/api/organizations/%s/tags/%s", orgId, tagId);

        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() == 204) {
                System.out.println("Tag " + tagId + " deleted permanently.");
            } else {
                System.err.println("Failed to delete tag " + tagId + ". Status: " + response.statusCode());
                System.err.println("Response Body: " + 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" }
  tagId := "TAG_ID_TO_DELETE"
  apiUrl := fmt.Sprintf("https://go.tallyfy.com/api/organizations/%s/tags/%s", orgId, tagId)

  client := &http.Client{Timeout: 15 * time.Second}
  req, err := http.NewRequest(http.MethodDelete, apiUrl, nil)
  if err != nil {
    fmt.Printf("Error creating request for tag %s: %v\n", tagId, 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 for tag %s: %v\n", tagId, err)
    return
  }
  defer resp.Body.Close()

  if resp.StatusCode == http.StatusNoContent {
    fmt.Printf("Tag %s deleted permanently.\n", tagId)
  } else {
    body, _ := io.ReadAll(resp.Body)
    fmt.Printf("Failed to delete tag %s. Status: %d\nBody: %s\n", tagId, 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> DeleteTallyfyTag(const utility::string_t& tagId)
{
    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("/tags/") + tagId;

    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([tagId](http_response response)
    {
        if (response.status_code() == status_codes::NoContent) {
            std::wcout << L"Tag " << tagId << L" deleted permanently." << std::endl;
        } else {
            return response.extract_string().then([tagId, response](utility::string_t body)
            {
                std::wcerr << L"Failed to delete tag " << tagId
                           << L". Status: " << response.status_code() << std::endl;
                std::wcerr << L"Response: " << body << std::endl;
                throw std::runtime_error("Failed to delete tag");
            });
        }
        return pplx::task_from_result();
    });
}

int main() {
    try {
        DeleteTallyfyTag(U("TAG_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 TallyfyTagDeleter
{
    private static readonly HttpClient client = new HttpClient();

    public static async Task DeleteTagAsync(string tagId)
    {
        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}/tags/{tagId}";

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

            if (response.StatusCode == System.Net.HttpStatusCode.NoContent)
            {
                Console.WriteLine($"Tag {tagId} deleted permanently.");
            }
            else
            {
                string responseBody = await response.Content.ReadAsStringAsync();
                Console.WriteLine($"Failed to delete tag {tagId}. Status: {response.StatusCode}");
                Console.WriteLine($"Response: {responseBody}");
            }
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"Request exception deleting tag {tagId}: {e.Message}");
        }
    }

    // Example Usage:
    // static async Task Main(string[] args)
    // {
    //     await DeleteTagAsync("TAG_ID_TO_DELETE");
    // }
}

Response

A successful delete returns 204 No Content with an empty response body. The tag and all its associations are permanently removed.

If the tag ID doesn’t exist, the endpoint still returns 204 — it won’t error on a missing tag.

Tasks > Delete task

Tallyfy’s API lets you permanently delete a standalone one-off task along with its form fields…

Processes > Delete process

Tallyfy’s API lets admins permanently delete an archived process run and all its related data…

Groups > Delete group

Tallyfy’s DELETE endpoint at /organizations/[org_id]/groups/[group_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?

Get in touch

About Tallyfy