Get group

Endpoint

GET /organizations/{org_id}/groups/{group_id}

This endpoint retrieves details for a specific group in your Tallyfy organization.

Request

Replace {org_id} with your Organization ID and {group_id} with the group’s ID.

Headers

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

Query parameters (optional)

Parameter	Type	Description
`with`	string	Include related data. Supported: `assets` (group logo).

Code samples

const accessToken = 'YOUR_PERSONAL_ACCESS_TOKEN';
const orgId = 'YOUR_ORGANIZATION_ID';
const groupId = 'GROUP_ID_TO_GET';

const queryParams = '?with=assets';
const apiUrl = `https://go.tallyfy.com/api/organizations/${orgId}/groups/${groupId}${queryParams}`;

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

fetch(apiUrl, { method: 'GET', headers })
.then(response => {
    return response.json().then(data => {
        if (!response.ok) {
            console.error(`Failed to get group ${groupId}:`, data);
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        return data;
    });
})
.then(data => {
    console.log(`Successfully retrieved group ${groupId}:`);
    console.log(JSON.stringify(data, null, 2));
})
.catch(error => {
    console.error(`Error getting group ${groupId}:`, error.message);
});

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_GET'
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'
}

params = {
    'with': 'assets'
}

response = requests.get(api_url, headers=headers, params=params)
response.raise_for_status()

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

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class GetGroup {
    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_GET";
        String apiUrl = String.format(
            "https://go.tallyfy.com/api/organizations/%s/groups/%s?with=assets",
            orgId, groupId);

        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")
                .GET()
                .build();

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

            if (response.statusCode() == 200) {
                System.out.println("Successfully retrieved group " + groupId + ":");
                System.out.println(response.body());
            } else {
                System.err.println("Failed to get 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();
        }
    }
}

package main

import (
  "bytes"
  "encoding/json"
  "fmt"
  "io"
  "net/http"
  "net/url"
  "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_GET"
  baseURL := fmt.Sprintf("https://go.tallyfy.com/api/organizations/%s/groups/%s", orgId, groupId)

  queryParams := url.Values{}
  queryParams.Add("with", "assets")
  apiURL := baseURL + "?" + queryParams.Encode()

  client := &http.Client{Timeout: 15 * time.Second}
  req, err := http.NewRequest("GET", apiURL, nil)
  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")

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

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

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

  fmt.Printf("Successfully retrieved 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))
  }
}

#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> GetTallyfyGroup(const utility::string_t& groupId)
{
    utility::string_t accessToken = U("YOUR_PERSONAL_ACCESS_TOKEN");
    utility::string_t orgId = U("YOUR_ORGANIZATION_ID");

    uri_builder builder(U("https://go.tallyfy.com/api/organizations/"));
    builder.append_path(orgId);
    builder.append_path(U("groups"));
    builder.append_path(groupId);
    builder.append_query(U("with"), U("assets"));
    utility::string_t apiUrl = builder.to_string();

    http_client client(apiUrl);
    http_request request(methods::GET);

    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([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::OK) {
                    std::wcout << L"Successfully retrieved group " << gId << L":\n" << body.serialize() << std::endl;
                } else {
                    std::wcerr << L"Failed to get 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 {
        GetTallyfyGroup(U("GROUP_ID_TO_GET")).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;
using System.Text.Json;

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

    public static async Task GetGroupAsync(string groupId)
    {
        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}?with=assets";

        using var request = new HttpRequestMessage(HttpMethod.Get, 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);
        string responseBody = await response.Content.ReadAsStringAsync();

        if (response.IsSuccessStatusCode)
        {
            Console.WriteLine($"Successfully retrieved group {groupId}:");
            using var doc = JsonDocument.Parse(responseBody);
            Console.WriteLine(JsonSerializer.Serialize(doc.RootElement, new JsonSerializerOptions { WriteIndented = true }));
        }
        else
        {
            Console.WriteLine($"Failed to get group {groupId}. Status: {response.StatusCode}");
            Console.WriteLine($"Response: {responseBody}");
        }
    }

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

Response

A successful request returns a 200 OK status with a JSON object containing the group’s details in the data property.

Response fields

Field	Type	Description
`id`	string	Unique identifier for the group
`name`	string	Name of the group
`description`	string	Description of the group
`logo`	string	URL of the group’s logo image
`members`	array	List of member user IDs in this group
`guests`	array	List of guest email addresses in this group
`created_at`	string	Timestamp when the group was created
`last_updated`	string	Timestamp when the group was last modified

If you include with=assets, the response also contains an assets property with logo file details.

Example response

{
  "data": {
    "id": "group_id_here",
    "name": "Engineering Team",
    "description": "Core engineering group",
    "logo": null,
    "members": ["user_id_1", "user_id_2"],
    "guests": ["guest@example.com"],
    "created_at": "2024-01-15T10:30:00.000Z",
    "last_updated": "2024-06-20T14:45:00.000Z"
  }
}

Groups > List groups

Tallyfy’s API lets you retrieve a paginated list of all groups in your organization via a GET request to /organizations/[org_id]/groups with optional filters for searching by name and sorting plus the ability to include related assets or users in the response.

Members > Get member

Tallyfy’s API lets admin users fetch a specific organization member’s profile by their numeric user ID through a GET request and optionally include related data like stats and groups and preferences in the response.

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 > List members

Tallyfy’s API lets you retrieve a paginated list of all organization members via a GET request with optional filtering by name or email and sorting and the ability to include related data like groups and stats in the response.

Was this helpful?

Get in touch

About Tallyfy