---
title: Delete tag · Tallyfy Pro
description: Tallyfy's DELETE API endpoint at `/organizations/{org_id}/tags/{tag_id}` permanently removes a tag and all its associations with templates and processes and steps and tasks in an irreversible operation that returns a 204 No Content response on success.
lastUpdated: 2026-09-22T00:00:00.000Z
source_url:
  html: https://tallyfy.com/products/pro/integrations/open-api/code-samples/tags/archive-tag/
  md: https://tallyfy.com/products/pro/integrations/open-api/code-samples/tags/archive-tag/index.md
---

## Endpoint

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

This permanently deletes a tag. It also takes the tag off every template, process, step and task that has it. You can’t undo this.

Tags can’t be archived, so there’s no archive or restore endpoint for them. This page’s web address ends in `archive-tag` for historical reasons. The endpoint only deletes.

## Request

Replace `{org_id}` with your organization ID. Replace `{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

* Javascript

  ```javascript
  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);
  });
  ```

* Python

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

* Java

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

* Go

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

* C++

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

* C#

  ```csharp
  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

You’ll get `204 No Content`. The response body is empty. The tag is gone for good, along with every link to it.

If the tag ID doesn’t exist, you still get `204`. The endpoint won’t error on a missing tag.

***

## Related articles

[**Processes > Delete process**](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/delete-process/)

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

[**Templates > Archive or delete template**](https://tallyfy.com/products/pro/integrations/open-api/code-samples/templates/delete-archive-template/)

Tallyfy”s API lets you remove templates in two steps. First archive (soft delete) with a DELETE…

[**Tasks > Delete task**](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/delete-task/)

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

[**Tasks > Archive task**](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/archive-task/)

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

## Was this helpful?