Update template

Endpoint

PUT /organizations/{org_id}/checklists/{checklist_id}

Updates the properties of an existing template (blueprint) by its ID.

Request

Replace {org_id} with your Organization ID and {checklist_id} with the template ID.

Headers

• 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. The title field is required on every update request (max 250 characters). All other fields are optional.

Required field:

• title (string, required) - Template title, max 250 characters

Common optional fields:

• owner_id (string) - Must be a valid user in your organization
• webhook (string) - Must be a valid URL
• guidance (string) - Guidance text for the template
• icon (string) - Icon identifier
• folder_id (string) - Folder ID to organize this template
• is_public (boolean) - Make the template publicly accessible
• is_public_kickoff (boolean) - Enable public kick-off form
• explanation_video (string) - Must be a valid URL
• default_process_name_format (string, max 550) - Auto-naming format for launched processes
• auto_naming (boolean) - Enable automatic process naming
• users (array of strings) - Replaces the entire existing user list
• groups (array of strings) - Replaces the entire existing group list

Example body:

{
  "title": "Updated Template Name",
  "guidance": "New guidance notes for this template."
}

Updating arrays (users/groups)

When you update users or groups, the provided array replaces the entire existing list. It won’t append new entries, so make sure you include the complete intended list.

Code samples

Javascript

const accessToken = 'YOUR_PERSONAL_ACCESS_TOKEN';
const orgId = 'YOUR_ORGANIZATION_ID';
const checklistId = 'TEMPLATE_ID_TO_UPDATE';
const apiUrl = `https://go.tallyfy.com/api/organizations/${orgId}/checklists/${checklistId}`;

const updateData = {
  title: "Updated via JS Fetch",
  guidance: "New guidance added via API.",
  // Note: Updating 'users' or 'groups' replaces the entire list.
  // users: ["user_id_1", "user_id_2"]
};

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 template ${checklistId}:`, data);
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        return data;
    });
})
.then(data => {
    console.log(`Successfully updated template ${checklistId}:`);
    console.log(JSON.stringify(data, null, 2));
})
.catch(error => {
    console.error(`Error updating template ${checklistId}:`, 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')
checklist_id = 'TEMPLATE_ID_TO_UPDATE'
api_url = f'https://go.tallyfy.com/api/organizations/{org_id}/checklists/{checklist_id}'

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

# title is required on every update. users/groups arrays replace existing lists.
update_payload = {
    'title': 'Updated Template Title',
    'guidance': 'New guidance notes added via Python.',
}

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

if response.status_code == 200:
    updated_template = response.json()
    print(f'Successfully updated template {checklist_id}:')
    print(json.dumps(updated_template, indent=4))
else:
    print(f"Failed to update template {checklist_id}: {response.status_code}")
    print(response.text)

Java

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

public class UpdateTemplate {

    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 checklistId = "TEMPLATE_ID_TO_UPDATE";
        String apiUrl = "https://go.tallyfy.com/api/organizations/" + orgId + "/checklists/" + checklistId;

        // title is required. Using Jackson/Gson is recommended for real projects.
        String jsonPayload = "{\"title\": \"Java Updated Template Title\", \"guidance\": \"Updated via Java\"}";
        // Note: Updating users/groups arrays replaces the entire existing list.

        HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(10))
                .build();

        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 template " + checklistId + ":");
                System.out.println(response.body());
                // Parse JSON response as needed
            } else {
                System.err.println("Failed to update template " + checklistId + ". 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"
  }
  checklistId := "TEMPLATE_ID_TO_UPDATE"
  apiUrl := fmt.Sprintf("https://go.tallyfy.com/api/organizations/%s/checklists/%s", orgId, checklistId)

  // title is required. users/groups arrays replace existing lists.
  updateData := map[string]interface{}{
    "title":    "Go Updated Template",
    "guidance": "Updated via Go net/http PUT request.",
  }

  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 PUT request: %v\n", 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 making PUT request: %v\n", err)
    return
  }
  defer resp.Body.Close()

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

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

  fmt.Printf("Successfully updated template %s:\n", checklistId)
  var prettyJSON bytes.Buffer
  if err := json.Indent(&prettyJSON, body, "", "  "); err == nil {
    fmt.Println(prettyJSON.String())
  } else {
    fmt.Println(string(body))
  }
}

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> UpdateTallyfyTemplate(const utility::string_t& checklistId, 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("/checklists/") + checklistId;

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

int main() {
    try {
        value payload = value::object();
        payload[U("title")] = value::string(U("C++ API Updated Template"));
        payload[U("guidance")] = value::string(U("Updated guidance via C++"));
        // Note: Updating users/groups arrays replaces the entire existing list.

        UpdateTallyfyTemplate(U("TEMPLATE_ID_TO_UPDATE"), payload).wait();
    } 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.Collections.Generic;
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 TallyfyTemplateUpdater
{
    private static readonly HttpClient client = new HttpClient();

    public class TemplateUpdatePayload
    {
        // title is required on every update. Other fields are optional.
        public string Title { get; set; } // Required, max 250 chars
        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
        public string OwnerId { get; set; }
        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
        public string Webhook { get; set; }
        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
        public string Guidance { get; set; }
        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
        public string Icon { get; set; }
        // Note: Updating Users/Groups REPLACES the entire existing list.
        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
        public List<string> Users { get; set; }
        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
        public List<string> Groups { get; set; }
    }

    public static async Task UpdateTemplateAsync(string checklistId, TemplateUpdatePayload 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}/checklists/{checklistId}";

        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
            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)
            {
                Console.WriteLine($"Successfully updated template {checklistId}:");
                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 template {checklistId}. Status: {response.StatusCode}");
                Console.WriteLine($"Response: {responseBody}");
            }
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"Request Exception updating template {checklistId}: {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 templateUpdate = new TemplateUpdatePayload {
    //         Title = "Updated via C#",
    //         Guidance = "New guidance notes"
    //     };
    //     await UpdateTemplateAsync("TEMPLATE_ID_TO_UPDATE", templateUpdate);
    // }
}

Response

A successful request returns a 200 OK status code and a JSON object with the full template details after the update.

{
  "data": {
    "id": "TEMPLATE_ID_TO_UPDATE",
    "title": "Updated via JS Fetch",
    "guidance": "New guidance added via API.",
    "owner_id": "user_id_here",
    "webhook": null,
    "is_public": false,
    "type": "procedure",
    "users": [],
    "groups": [],
    "last_updated": "2026-01-15T12:30:00.000Z"
  }
}

If the template isn’t found, you’ll get a 404. Permission issues return 403. Validation errors - like a missing title - return 422.

---

Related articles

Templates > Create a template

Tallyfy’s API lets you create a new process template by sending a POST request to the checklists…

Tasks > Update task

Tallyfy’s API lets you update any task (process or one-off) via a PUT request where you can…

Tags > Update tag

Modify an existing tag’s title (up to 30 characters, unique per organization) or hex color code…

Processes > Update process

Tallyfy’s API lets you partially update a running process by sending a PUT request with only the…

Was this helpful?

YesNo