Update group

Endpoint

PUT /organizations/{org_id}/groups/{group_id}

Updates a group’s details or membership within your Tallyfy organization. The caller must have manage_groups permission.

Request

Replace {org_id} with your Organization ID and {group_id} with the ID of the group to update.

Headers

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

Body (JSON)

Field	Type	Required	Description
name	string	No	New name (max 200 characters, must be unique per org)
description	string	Yes	Group description
members	array of integers	No	Replaces the entire member list with these user IDs
guests	array of strings	No	Replaces the entire guest list with these emails

Membership updates replace

Providing the members or guests arrays replaces the entire existing list for that type. To add or remove individuals incrementally, first GET the current group details, modify the list in your code, then send the complete new list in the PUT request.

Code samples

Javascript

const accessToken = 'YOUR_PERSONAL_ACCESS_TOKEN';
const orgId = 'YOUR_ORGANIZATION_ID';
const groupId = 'GROUP_ID_TO_UPDATE';
const apiUrl = `https://go.tallyfy.com/api/organizations/${orgId}/groups/${groupId}`;

const updateData = {
  description: "Updated team description.",
  members: [1001, 1003, 1005],
  guests: []
};

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 => {
    if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
    return response.json();
})
.then(data => {
    console.log(`Successfully updated group ${groupId}:`);
    console.log(JSON.stringify(data, null, 2));
})
.catch(error => {
    console.error(`Error updating group ${groupId}:`, 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')
group_id = 'GROUP_ID_TO_UPDATE'
api_url = f'https://go.tallyfy.com/api/organizations/{org_id}/groups/{group_id}'

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

update_payload = {
    'name': 'Finance Approvers (Updated)',
    'description': 'Core finance team for approvals.',
    'members': [1004, 1006, 1007],
    'guests': []
}

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

updated_group = response.json()
print(f'Successfully updated group {group_id}:')
print(json.dumps(updated_group, indent=4))

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 UpdateGroup {
    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 groupId = "GROUP_ID_TO_UPDATE";
        String apiUrl = String.format("https://go.tallyfy.com/api/organizations/%s/groups/%s", orgId, groupId);

        String jsonPayload = "{\"name\": \"Renamed Java Group\", \"description\": \"Updated description.\"}";

        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() == 201) {
                System.out.println("Successfully updated group " + groupId + ":");
                System.out.println(response.body());
            } else {
                System.err.println("Failed to update group " + groupId + ". 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

package main

import (
  "bytes"
  "encoding/json"
  "fmt"
  "io/ioutil"
  "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" }
  groupId := "GROUP_ID_TO_UPDATE"
  apiUrl := fmt.Sprintf("https://go.tallyfy.com/api/organizations/%s/groups/%s", orgId, groupId)

  updateData := map[string]interface{}{
    "name":        "Go Updated Group",
    "description": "Updated via Go client.",
    "members":     []int{1010, 1012},
    "guests":      []string{},
  }

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

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

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

  fmt.Printf("Successfully updated group %s:\n", groupId)
  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> UpdateTallyfyGroup(const utility::string_t& groupId, 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("/groups/") + groupId;

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

int main() {
    try {
        value payload = value::object();
        payload[U("name")] = value::string(U("C++ Updated Group Name"));
        payload[U("description")] = value::string(U("Updated via C++ client."));
        value members = value::array();
        members[0] = value::number(1001);
        members[1] = value::number(1015);
        payload[U("members")] = members;

        UpdateTallyfyGroup(U("GROUP_ID_TO_UPDATE"), payload).wait();
    } catch (const std::exception &e) {
        std::cerr << "Error: " << 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.Threading.Tasks;

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

    public class GroupUpdatePayload
    {
        public string Name { get; set; }
        public string Description { get; set; }
        public List<int> Members { get; set; }
        public List<string> Guests { get; set; }
    }

    public static async Task UpdateGroupAsync(string groupId, GroupUpdatePayload 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}/groups/{groupId}";

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

        var options = new JsonSerializerOptions {
            DefaultIgnoreCondition = System.Text.Json.Serialization.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 group {groupId}:");
            using var doc = JsonDocument.Parse(responseBody);
            Console.WriteLine(JsonSerializer.Serialize(doc.RootElement, new JsonSerializerOptions { WriteIndented = true }));
        }
        else
        {
            Console.WriteLine($"Failed to update group {groupId}. Status: {response.StatusCode}");
            Console.WriteLine($"Response: {responseBody}");
        }
    }

    // Example usage:
    // static async Task Main(string[] args)
    // {
    //     var update = new GroupUpdatePayload {
    //         Description = "Core finance team for approvals.",
    //         Members = new List<int> { 1004, 1007 }
    //     };
    //     await UpdateGroupAsync("GROUP_ID_TO_UPDATE", update);
    // }
}

Response

A successful request returns a 201 Created status and a JSON object containing the full group details after the update, wrapped in a data object.

{
  "data": {
    "id": "GROUP_ID_TO_UPDATE",
    "name": "Project Alpha Core Team",
    "description": "Updated team description.",
    "logo": null,
    "members": [1001, 1008, 1010],
    "guests": [],
    "created_at": "2025-01-15T10:30:00.000000Z",
    "last_updated": "2025-06-20T14:22:00.000000Z"
  }
}

If the group ID isn’t found, you lack permission, or the request body is invalid, expect a 404, 403, 400, or 422 error.

---

Related articles

Groups > Create group

Tallyfy’s API lets you create a new group by sending a POST request to /organizations/[org_id]/groups with a unique name and description along with optional member user IDs and guest email addresses and returns the new group’s details including its ID for future operations.

Members > Update member

Tallyfy’s API lets admins update a member’s profile (name and timezone and optional fields like phone or job title) via a PUT request to /organizations/[org_id]/users/[user_id] and returns the full updated profile on success.

Guests > Update guest

Tallyfy’s PUT endpoint at /organizations/[org_id]/guests/[guest_email] lets you update only the associated_members field for an existing guest by sending an array of member IDs and returns the full guest record with a 201 status on success.

Code Samples > Managing groups

Tallyfy’s Groups API lets you bundle members and guests into reusable groups that can be assigned to tasks and processes through standard create/list/get/update/delete operations scoped to your organization.

Was this helpful?

YesNo