List templates

List Templates API Endpoint

This endpoint retrieves a list of process templates (known as “Checklists” or “Blueprints” in the API) available within the specified organization.

Endpoint

GET /organizations/{org_id}/checklists

Request

Replace {org_id} with your actual Organization ID.

Headers

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

Query parameters (optional)

Refer to the GET /organizations/{org}/checklists endpoint in the Swagger specification or API reference for optional query parameters like with, type, q (search), page, per_page, etc., to filter or paginate results.

Code samples

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

const queryParams = '?per_page=20&with=owner'; // Example: Get 20 templates per page and include owner details
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 => { // Attempt to parse JSON regardless of status
        if (!response.ok) {
            console.error("Failed to list templates:", data);
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        return data; // Pass successful data along
    });
})
.then(data => {
    console.log('Successfully retrieved templates:');
    console.log(JSON.stringify(data, null, 2));
    // Access pagination info via data.meta.pagination if needed
})
.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: Add query parameters for filtering/pagination
params = {
     'q': 'Onboarding', # Example: Search for templates with 'Onboarding' in the title
     'per_page': 5,
     'with': 'owner' # Example: Include owner 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))
    # Access pagination: templates_data.get('meta', {}).get('pagination')

except requests.exceptions.HTTPError as http_err:
    print(f"HTTP error occurred 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 listing templates: {req_err}")
except json.JSONDecodeError:
    print("Failed to decode JSON response when listing templates")
    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.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: Add query parameters
        Map<String, String> queryParamsMap = new HashMap<>();
        // queryParamsMap.put("q", "Onboarding");
        queryParamsMap.put("per_page", "5");
        queryParamsMap.put("with", "owner");

        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/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/checklists", orgId)

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

    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 := ioutil.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"));
    // Add optional query parameters
    builder.append_query(U("q"), U("Onboarding"));
    builder.append_query(U("per_page"), 5);
    builder.append_query(U("with"), U("owner"));
    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;
                    // Access data: body[U("data")].as_array()
                    // Access pagination: body[U("meta")][U("pagination")]
                } 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"; // Example search
        query["per_page"] = "5";
        query["with"] = "owner"; // Example include
        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:");
                // 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 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 code and a JSON object containing a data array. Each element in the data array represents a template with its details.

{
  "data": [
    {
      "id": "c15bf2be31c3a7fbded5d13fce7aaab9",
      "title": "Customer Onboarding Process",
      "summary": "Standard process for onboarding new customers.",
      "starred": false,
      // ... other template properties ...
      "created_at": "2023-01-10T10:00:00.000Z",
      "last_updated": "2023-05-15T14:30:00.000Z"
    },
    {
      "id": "a987654321abcdefa987654321abcdef",
      "title": "Employee Offboarding Checklist",
      "summary": "Steps to take when an employee leaves.",
      // ... other template properties ...
    }
    // ... more templates ...
  ],
  "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"
       }
    }
  }
}

If pagination is used, the meta object provides details about the total number of templates, current page, etc., and links to navigate through pages.

Templates > Get template

An API endpoint that retrieves detailed information about a specific process template using a GET request with optional parameters to include related data such as steps tags and folder hierarchies.

Code Samples > Managing templates (blueprints)

API endpoints enable managing process templates through actions like creating retrieving updating publishing exporting and deleting template definitions in an organization.

Processes > List processes

The GET endpoint retrieves and filters process instances within an organization providing paginated results with detailed run information task status and optional related data through various query parameters.

Templates > Create a template

A comprehensive POST endpoint for creating organization templates with customizable properties including title summary owner permissions and various configuration options for process management.

Get in touch

About Tallyfy