List templates

List all templates

This endpoint returns a paginated list of templates (called “checklists” in the API) for a given organization.

Endpoint

GET /organizations/{org_id}/checklists

Request

Replace {org_id} with your Organization ID.

Headers

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

Query parameters (optional)

Parameter	Type	Description
`q`	string	Search templates by title (case-insensitive partial match)
`page`	integer	Page number for pagination
`per_page`	integer	Results per page (default: 10)
`sort_by`	string	Field to sort by (prefix with `-` for descending)
`with`	string	Comma-separated includes: `steps`, `tags`, `folder`, `permissions`, `stages`, `linked_tasks`, `assets`, `member_watchers`, `guest_watchers`
`status`	string	Filter by template status
`type`	string	Filter by template type
`starred`	string	Filter starred templates
`folder`	string	Filter by folder
`tag`	string	Filter by tag
`owner_id`	string	Filter by owner
`archived`	string	Set to `only` for archived templates, or any truthy value to include them

Code samples

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

const queryParams = '?per_page=10&with=steps'; // Example: Get 10 templates per page with their steps
const apiUrl = `https://go.tallyfy.com/api/organizations/${orgId}/checklists${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 => {
        if (!response.ok) {
            console.error("Failed to list templates:", data);
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        return data;
    });
})
.then(data => {
    console.log('Successfully retrieved templates:');
    console.log(JSON.stringify(data, null, 2));
    // Access pagination via data.meta.pagination
})
.catch(error => {
    console.error('Error listing templates:', 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')
api_url = f'https://go.tallyfy.com/api/organizations/{org_id}/checklists'

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

# Optional query parameters for filtering/pagination
params = {
     'q': 'Onboarding', # Search templates by title
     'per_page': 10,
     'with': 'steps' # Include step details
}

response = None
try:
    response = requests.get(api_url, headers=headers, params=params)
    response.raise_for_status() # Check for HTTP errors (4xx or 5xx)

    templates_data = response.json()
    print('Successfully retrieved templates:')
    print(json.dumps(templates_data, indent=4))
    # Pagination info: templates_data.get('meta', {}).get('pagination')

except requests.exceptions.HTTPError as http_err:
    print(f"HTTP error listing templates: {http_err}")
    if response is not None:
        print(f"Response Body: {response.text}")
except requests.exceptions.RequestException as req_err:
    print(f"Request failed: {req_err}")
except json.JSONDecodeError:
    print("Failed to decode JSON response")
    if response is not None:
        print(f"Response Text: {response.text}")

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.time.Duration;
import java.util.Map;
import java.util.HashMap; // Use HashMap for mutable map
import java.util.stream.Collectors;

public class ListTemplates {

    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 + "/checklists";

        // Optional query parameters
        Map<String, String> queryParamsMap = new HashMap<>();
        // queryParamsMap.put("q", "Onboarding");
        queryParamsMap.put("per_page", "10");
        queryParamsMap.put("with", "steps");

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

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

            if (response.statusCode() == 200) {
                System.out.println("Successfully retrieved templates:");
                System.out.println(response.body());
                // TODO: Consider parsing the JSON response using Jackson or Gson
            } else {
                System.err.println("Failed to list templates. 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"
  "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/checklists", orgId)

    // Optional query parameters
    queryParams := url.Values{}
    queryParams.Add("q", "Onboarding")
    queryParams.Add("per_page", "10")
    queryParams.Add("with", "steps")

    apiUrl := baseURL
    if len(queryParams) > 0 {
        apiUrl += "?" + queryParams.Encode()
    }

  client := &http.Client{Timeout: 15 * time.Second}
  req, err := http.NewRequest("GET", apiUrl, nil)
  if err != nil {
    fmt.Printf("Error creating list templates 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 making list templates request: %v\n", err)
    return
  }
  defer resp.Body.Close()

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

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

  fmt.Println("Successfully retrieved templates:")
    // 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 Go 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> ListTallyfyTemplates()
{
    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("checklists"));
    // Optional query parameters
    builder.append_query(U("q"), U("Onboarding"));
    builder.append_query(U("per_page"), 10);
    builder.append_query(U("with"), U("steps"));
    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 retrieved templates:\n" << body.serialize() << std::endl;
                } else {
                    std::wcerr << L"Failed to list templates. Status: " << response.status_code() << L"\nResponse: " << body.serialize() << std::endl;
                }
            } catch (const http_exception& e) {
                 std::wcerr << L"HTTP exception during list templates: " << e.what() << std::endl;
            } catch (const std::exception& e) {
                std::wcerr << L"Exception during list templates response handling: " << e.what() << std::endl;
            }
        });
    });
}

int main() {
    try {
        ListTallyfyTemplates().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 TallyfyTemplateLister
{
    private static readonly HttpClient client = new HttpClient();

    public static async Task ListTemplatesAsync()
    {
        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["q"] = "Onboarding";
        query["per_page"] = "10";
        query["with"] = "steps";
        string queryString = query.ToString();
        var apiUrl = $"https://go.tallyfy.com/api/organizations/{orgId}/checklists?{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 retrieved templates:");
                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 list templates. Status: {response.StatusCode}");
                Console.WriteLine($"Response: {responseBody}");
            }
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"Request Exception listing templates: {e.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An unexpected error occurred: {ex.Message}");
        }
    }

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

Response

A successful request returns a 200 OK status and a JSON object with a data array. Each item in the array represents a template with fields like id, title, summary, starred, type, status, owner_id, created_by, created_at, last_updated, and more.

{
  "data": [
    {
      "id": "c15bf2be31c3a7fbded5d13fce7aaab9",
      "title": "Customer Onboarding Process",
      "summary": "Standard process for onboarding new customers.",
      "starred": false,
      "type": "procedure",
      "status": "active",
      "owner_id": "user_abc123",
      "created_by": "user_abc123",
      "steps_count": 8,
      "is_pinned": false,
      "created_at": "2025-01-10T10:00:00.000Z",
      "last_updated": "2025-05-15T14:30:00.000Z"
    }
  ],
  "meta": {
    "pagination": {
       "total": 25,
       "count": 10,
       "per_page": 10,
       "current_page": 1,
       "total_pages": 3,
       "links": {
           "next": "https://go.tallyfy.com/api/organizations/{org_id}/checklists?page=2"
       }
    }
  }
}

The meta.pagination object tells you the total count, current page, items per page, and provides links for navigating between pages. Results are sorted by pinned status first, then by your sort_by parameter (defaults to updated).

Templates > Get template

Tallyfy’s API lets you fetch full details of any process template by its unique ID using a GET request and optionally include related data like steps and tags through query parameters.

Processes > List processes

Tallyfy’s API lets you retrieve a paginated and filterable list of all running process instances in your organization by calling GET on the runs endpoint with optional parameters for status and ownership and tags and sorting and related data inclusion.

Tasks > List organization tasks

Tallyfy’s API lets you retrieve and filter all tasks across an entire organization—including both process-based and one-off tasks—using a GET endpoint with extensive query parameters for status and deadline filtering and owner/guest/group assignment and sorting and pagination with code examples in six languages.

Tags > List tags

Tallyfy’s API lets you retrieve all tags in an organization via a GET request with optional filtering by name and pagination and can include usage statistics showing how many active or archived templates and processes each tag is associated with.

Was this helpful?

Get in touch

About Tallyfy