This API endpoint retrieves detailed information about a specific tag in an organization by its unique ID and supports optional parameters to include additional data like usage statistics.
List tags
GET /organizations/{org_id}/tags
This endpoint retrieves a list of tags available within the specified organization.
Replace {org_id} with your Organization ID.
Authorization: Bearer {your_access_token}Accept: application/jsonX-Tallyfy-Client: APIClient
Refer to Swagger for filtering options, which might include:
q(string): Search by tag title.with(string): Include related data (e.g.,statistics).- Pagination parameters (
page,per_page). - Sorting parameters (
sort).
const accessToken = 'YOUR_PERSONAL_ACCESS_TOKEN';const orgId = 'YOUR_ORGANIZATION_ID';
const queryParams = '?with=statistics&page=1'; // Example: Include stats, get first pageconst apiUrl = `https://go.tallyfy.com/api/organizations/${orgId}/tags${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: headers}).then(response => { return response.json().then(data => { // Attempt to parse JSON regardless of status if (!response.ok) { console.error("Failed to list tags:", data); throw new Error(`HTTP error! status: ${response.status}`); } return data; // Pass successful data along });}).then(data => { console.log('Successfully listed tags:'); console.log(JSON.stringify(data, null, 2)); // Access pagination: data.meta.pagination}).catch(error => { console.error('Error listing tags:', error.message);});import requestsimport jsonimport os
access_token = os.environ.get('TALLYFY_ACCESS_TOKEN', 'YOUR_PERSONAL_ACCESS_TOKEN')org_id = os.environ.get('TALLYFY_ORG_ID', 'YOUR_ORGANIZATION_ID')api_url = f'https://go.tallyfy.com/api/organizations/{org_id}/tags'
headers = { 'Authorization': f'Bearer {access_token}', 'Accept': 'application/json', 'X-Tallyfy-Client': 'APIClient'}
# Optional: Add query parametersparams = { 'q': 'Project', # Example: Search for tags containing "Project" 'with': 'statistics'}
response = Nonetry: response = requests.get(api_url, headers=headers, params=params) response.raise_for_status() # Raises HTTPError for bad responses (4xx or 5xx)
tags_data = response.json() print('Successfully listed tags:') print(json.dumps(tags_data, indent=4)) # Access pagination: tags_data.get('meta', {}).get('pagination')
except requests.exceptions.HTTPError as http_err: print(f"HTTP error occurred listing tags: {http_err}") if response is not None: print(f"Response Body: {response.text}")except requests.exceptions.RequestException as req_err: print(f"Request failed listing tags: {req_err}")except json.JSONDecodeError: print("Failed to decode JSON response when listing tags") if response is not None: print(f"Response Text: {response.text}")except Exception as err: print(f"An unexpected error occurred: {err}")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;import java.util.Map;import java.util.HashMap; // Use HashMap for mutable mapimport java.util.stream.Collectors;
public class ListTags { 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 baseUrl = "https://go.tallyfy.com/api/organizations/" + orgId + "/tags";
// Optional: Add query parameters Map<String, String> queryParamsMap = new HashMap<>(); queryParamsMap.put("with", "statistics"); // queryParamsMap.put("q", "Search");
String queryParamsString = queryParamsMap.entrySet().stream() .map(entry -> URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8) + "=" + URLEncoder.encode(entry.getValue(), StandardCharsets.UTF_8)) .collect(Collectors.joining("&", "?", ""));
String apiUrl = baseUrl + (queryParamsMap.isEmpty() ? "" : queryParamsString);
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 listed tags:"); System.out.println(response.body()); // TODO: Consider parsing JSON using Jackson/Gson } else { System.err.println("Failed to list tags. 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(); } }}package main
import ( "bytes" "encoding/json" "fmt" "io/ioutil" "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" } baseURL := fmt.Sprintf("https://go.tallyfy.com/api/organizations/%s/tags", orgId)
// Optional: Add query parameters queryParams := url.Values{} queryParams.Add("with", "statistics") // queryParams.Add("q", "Search")
apiUrl := baseURL if len(queryParams) > 0 { apiUrl += "?" + queryParams.Encode() }
client := &http.Client{Timeout: 10 * time.Second} req, err := http.NewRequest("GET", apiUrl, nil) if err != nil { fmt.Printf("Error creating list tags 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 list tags request: %v\n", err) return } defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body) if err != nil { fmt.Printf("Error reading list tags response body: %v\n", err) return }
if resp.StatusCode != http.StatusOK { fmt.Printf("Failed to list tags. Status: %d\nBody: %s\n", resp.StatusCode, string(body)) return }
fmt.Println("Successfully listed tags:") // 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 into a slice of tag structs if needed}#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> ListTallyfyTags(){ 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("tags")); builder.append_query(U("with"), U("statistics")); // Example query parameter // builder.append_query(U("q"), U("Search")); 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([](http_response response) { return response.extract_json().then([response](pplx::task<value> task) { try { value const & body = task.get(); if (response.status_code() == status_codes::OK) { std::wcout << L"Successfully listed tags:\n" << body.serialize() << std::endl; // Access data: body[U("data")].as_array() // Access pagination: body[U("meta")][U("pagination")] } else { std::wcerr << L"Failed to list tags. Status: " << response.status_code() << L"\nResponse: " << body.serialize() << std::endl; } } catch (const http_exception& e) { std::wcerr << L"HTTP exception during list tags: " << e.what() << std::endl; } catch (const std::exception& e) { std::wcerr << L"Exception during list tags response handling: " << e.what() << std::endl; } }); });}
int main() { try { ListTallyfyTags().wait(); } catch (const std::exception &e) { std::cerr << "Error in main: " << 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;using System.Web; // For HttpUtility
public class TallyfyTagLister{ private static readonly HttpClient client = new HttpClient();
public static async Task ListTagsAsync() { var accessToken = Environment.GetEnvironmentVariable("TALLYFY_ACCESS_TOKEN") ?? "YOUR_PERSONAL_ACCESS_TOKEN"; var orgId = Environment.GetEnvironmentVariable("TALLYFY_ORG_ID") ?? "YOUR_ORGANIZATION_ID";
// Build URL with query parameters var query = HttpUtility.ParseQueryString(string.Empty); query["with"] = "statistics"; // Example // query["q"] = "Search Term"; string queryString = query.ToString(); var apiUrl = $"https://go.tallyfy.com/api/organizations/{orgId}/tags?{queryString}";
try { 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 listed tags:"); // Pretty print JSON try { using var doc = JsonDocument.Parse(responseBody); Console.WriteLine(JsonSerializer.Serialize(doc.RootElement, new JsonSerializerOptions { WriteIndented = true })); // Access pagination: doc.RootElement.GetProperty("meta").GetProperty("pagination")... } catch (JsonException) { Console.WriteLine(responseBody); // Print raw if not valid JSON } } else { Console.WriteLine($"Failed to list tags. Status: {response.StatusCode}"); Console.WriteLine($"Response: {responseBody}"); } } catch (HttpRequestException e) { Console.WriteLine($"Request Exception listing tags: {e.Message}"); } catch (Exception ex) { Console.WriteLine($"An unexpected error occurred: {ex.Message}"); } }
// Example Usage: // static async Task Main(string[] args) // { // await ListTagsAsync(); // }}A successful request returns a 200 OK status code and a JSON object containing a data array. Each element represents a tag.
{ "data": [ { "id": "tag_id_abc", // Unique tag ID "title": "Urgent", "color": "#e74c3c", // Hex color code "template": 5, // Count of templates using this tag "active_process": 12, // Count of active processes using this tag "auto_generated": false, "created_at": "2025-01-15T10:00:00Z", "deleted_at": null, // Included if requested with 'with=statistics' "statistics": { // ... detailed usage counts ... } }, { "id": "tag_id_def", "title": "Finance", "color": "#2ecc71", // ... other tag details ... } ], "meta": { // Pagination details if applicable }} This endpoint enables retrieval of all registered members within a Tallyfy organization by making a GET request with optional query parameters for including related group data and pagination controls.
This documentation explains how to retrieve a list of groups within a Tallyfy organization using a GET API endpoint with code examples provided in JavaScript Python Java Go C++ and C# that demonstrate the request structure including required authorization headers and optional query parameters for including additional data like group logos.
Tasks > List organization tasks
The GET endpoint retrieves all tasks across an organization’s processes and one-off tasks with extensive filtering options including status assignees deadlines tags folders and pagination while supporting multiple programming languages through code samples that demonstrate query parameter construction and response handling.
Was this helpful?
About Tallyfy
- 2025 Tallyfy, Inc.
- Privacy Policy
- Terms of Use
- Report Issue
- Trademarks