Update tag

Endpoint

PUT /organizations/{org_id}/tags/{tag_id}

Updates the title or color of an existing tag.

Request

Replace {org_id} with your organization ID and {tag_id} with the tag ID to update.

Headers

Header	Value
Authorization	Bearer {your_access_token}
Accept	application/json
X-Tallyfy-Client	APIClient
Content-Type	application/json

Body (JSON)

Send a JSON object with the fields you want to change.

Field	Type	Required	Description
title	string	Yes	Tag name (max 30 characters, must be unique within your organization)
color	string	No	Hex color code (e.g. #ff0000)

Example body:

{
  "title": "High Priority (Red)",
  "color": "#ff0000"
}

Code samples

Javascript

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

const updateData = {
  title: "JS Updated Tag Name",
  color: "#1abc9c" // Turquoise
};

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

fetch(apiUrl, {
    method: 'PUT',
    headers: headers,
    body: JSON.stringify(updateData)
})
.then(response => {
    return response.json().then(data => {
        if (!response.ok) {
            console.error(`Failed to update tag ${tagId}:`, data);
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        return data;
    });
})
.then(data => {
    console.log(`Successfully updated tag ${tagId}:`);
    console.log(JSON.stringify(data, null, 2));
})
.catch(error => {
    console.error(`Error updating tag ${tagId}:`, error.message);
});

Python

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')
tag_id = 'TAG_ID_TO_UPDATE'
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',
    'Content-Type': 'application/json'
}

update_payload = {
    'title': 'Python Updated Tag',
    'color': '#34495e' # Dark blue/grey
}

response = None
try:
    response = requests.put(api_url, headers=headers, json=update_payload)
    response.raise_for_status()

    updated_tag = response.json()
    print(f'Successfully updated tag {tag_id}:')
    print(json.dumps(updated_tag, indent=4))

except requests.exceptions.HTTPError as http_err:
    print(f"HTTP error occurred updating 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 updating tag {tag_id}: {req_err}")
except json.JSONDecodeError:
    print(f"Failed to decode JSON response for tag update {tag_id}")
    if response is not None:
        print(f"Response Text: {response.text}")
except Exception as err:
     print(f"An unexpected error occurred: {err}")

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.io.IOException;
// Requires a JSON library like Jackson or Gson
// import com.fasterxml.jackson.databind.ObjectMapper;
// import java.util.Map;
// import java.util.HashMap;

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

        // --- Payload Construction ---
        // Using Jackson/Gson recommended:
        /*
        ObjectMapper mapper = new ObjectMapper();
        Map<String, String> updateData = new HashMap<>();
        updateData.put("title", "New Java Title"); // Required if updating
        updateData.put("color", "#ffffff"); // Optional
        String jsonPayload;
        try {
            jsonPayload = mapper.writeValueAsString(updateData);
        } catch (Exception e) {
            System.err.println("Failed to serialize JSON: " + e.getMessage());
            return;
        }
        */
        // Simple manual JSON string:
        String jsonPayload = "{\"title\": \"Java Updated Tag\", \"color\": \"#bdc3c7\"}";
        // --- End Payload ---

        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")
                .header("Content-Type", "application/json")
                .PUT(HttpRequest.BodyPublishers.ofString(jsonPayload))
                .build();

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

            if (response.statusCode() == 200) {
                System.out.println("Successfully updated tag " + tagId + ":");
                System.out.println(response.body());
                // TODO: Consider parsing JSON response
            } else {
                System.err.println("Failed to update 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();
        } catch (Exception e) {
             System.err.println("An unexpected error occurred: " + e.getMessage());
             e.printStackTrace();
        }
    }
}

Go

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" }
    tagId := "TAG_ID_TO_UPDATE"
    apiUrl := fmt.Sprintf("https://go.tallyfy.com/api/organizations/%s/tags/%s", orgId, tagId)

  updateData := map[string]interface{}{
    "title": "Go Updated Tag",
        "color": "#27ae60", // Green
  }

  jsonData, err := json.Marshal(updateData)
  if err != nil {
        fmt.Printf("Error marshalling JSON: %v\n", err)
        return
    }

  client := &http.Client{Timeout: 15 * time.Second}
  req, err := http.NewRequest(http.MethodPut, apiUrl, bytes.NewBuffer(jsonData))
    if err != nil {
        fmt.Printf("Error creating update tag 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")
  req.Header.Set("Content-Type", "application/json")

  resp, err := client.Do(req)
    if err != nil {
        fmt.Printf("Error executing update tag request for tag %s: %v\n", tagId, err)
        return
    }
  defer resp.Body.Close()

  body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Error reading update tag response body for tag %s: %v\n", tagId, err)
        return
    }

  if resp.StatusCode != http.StatusOK {
    fmt.Printf("Failed to update tag %s. Status: %d\nBody: %s\n", tagId, resp.StatusCode, string(body))
    return
  }

  fmt.Printf("Successfully updated tag %s:\n", tagId)
    // Pretty print JSON response
    var prettyJSON bytes.Buffer
    if err := json.Indent(&prettyJSON, body, "", "  "); err == nil {
        fmt.Println(prettyJSON.String())
    } else {
      fmt.Println(string(body))
    }
  // TODO: Unmarshal JSON if needed
}

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;
using namespace web::json;

pplx::task<void> UpdateTallyfyTag(const utility::string_t& tagId, const value& updatePayload)
{
    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::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"));
    request.headers().set_content_type(U("application/json"));
    request.set_body(updatePayload);

    return client.request(request).then([tagId](http_response response)
    {
        utility::string_t tagIdW = tagId;
        return response.extract_json().then([response, tagIdW](pplx::task<value> task)
        {
            try {
                value const & body = task.get();
                if (response.status_code() == status_codes::OK) {
                    std::wcout << L"Successfully updated tag " << tagIdW << L":\n" << body.serialize() << std::endl;
                } else {
                    std::wcerr << L"Failed to update tag " << tagIdW << L". Status: " << response.status_code() << L"\nResponse: " << body.serialize() << std::endl;
                }
            } catch (const http_exception& e) {
                 std::wcerr << L"HTTP exception during update tag: " << e.what() << std::endl;
            } catch (const std::exception& e) {
                std::wcerr << L"Exception during update tag response handling: " << e.what() << std::endl;
            }
        });
    });
}

int main() {
    try {
        value payload = value::object();
        payload[U("title")] = value::string(U("C++ Updated Tag"));
        payload[U("color")] = value::string(U("#ffffff")); // White

        UpdateTallyfyTag(U("TAG_ID_TO_UPDATE"), payload).wait(); // Replace with actual Tag ID
    } catch (const std::exception &e) {
        std::cerr << "Error in main: " << 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.Text;
using System.Text.Json;
using System.Text.Json.Serialization; // For JsonIgnoreCondition
using System.Threading.Tasks;

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

    public class TagUpdatePayload
    {
        // Include only fields you want to update. Use JsonIgnore for optional fields.
        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
        public string Title { get; set; }
        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
        public string Color { get; set; }
    }

    public static async Task UpdateTagAsync(string tagId, TagUpdatePayload payload)
    {
        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.Put, apiUrl);
            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            request.Headers.Add("X-Tallyfy-Client", "APIClient");

            // Serialize payload, ignore nulls so only provided fields are sent
            var options = new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull };
            string jsonPayload = JsonSerializer.Serialize(payload, options);
            request.Content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");

            HttpResponseMessage response = await client.SendAsync(request);
            string responseBody = await response.Content.ReadAsStringAsync();

            if (response.IsSuccessStatusCode) // Expect 200 OK
            {
                Console.WriteLine($"Successfully updated tag {tagId}:");
                try {
                    using var doc = JsonDocument.Parse(responseBody);
                    Console.WriteLine(JsonSerializer.Serialize(doc.RootElement, new JsonSerializerOptions { WriteIndented = true }));
                } catch (JsonException) {
                    Console.WriteLine(responseBody);
                }
            }
            else
            {
                Console.WriteLine($"Failed to update tag {tagId}. Status: {response.StatusCode}");
                Console.WriteLine($"Response: {responseBody}");
            }
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"Request Exception updating tag {tagId}: {e.Message}");
        }
         catch (JsonException jsonEx)
        {
             Console.WriteLine($"JSON Serialization Error: {jsonEx.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An unexpected error occurred: {ex.Message}");
        }
    }

    // Example Usage:
    // static async Task Main(string[] args)
    // {
    //     var tagUpdate = new TagUpdatePayload {
    //         Title = "C# Updated",
    //         Color = "#eeeeee"
    //     };
    //     await UpdateTagAsync("TAG_ID_TO_UPDATE", tagUpdate);
    // }
}

Response

A successful request returns a 200 OK status code and a JSON object with the updated tag.

{
  "data": {
    "id": "TAG_ID_TO_UPDATE",
    "title": "Python Updated Tag",
    "color": "#34495e",
    "auto_generated": false,
    "created_at": "2024-01-15T10:30:00.000Z",
    "deleted_at": null
  }
}

If the tag ID isn’t found or the payload fails validation, expect a 404, 422, or 400 error.

---

Related articles

Tags > Create tag

Tallyfy’s API lets you create organization tags by sending a POST request to the tags endpoint…

Code Samples > Managing tags

Tallyfy’s Tags API allows you to create and manage organization-scoped labels with unique titles…

Templates > Update template

Use the Tallyfy API to update an existing template’s properties through a PUT request. The title…

Groups > Update group

Tallyfy’s PUT endpoint for groups lets you rename a group or change its description and fully…

Was this helpful?

YesNo