A GET endpoint retrieves detailed information about a specific process run using organization and run IDs with optional parameters to include related data such as checklists tasks tags and form field values.
Get task
GET /organizations/{org_id}/tasks/{task_id}
This endpoint retrieves the full details for a single task (either a one-off task or a task within a process run) identified by its unique ID.
Replace {org_id}
with your Organization ID and {task_id}
with the specific ID of the task you want to retrieve.
Authorization: Bearer {your_access_token}
Accept: application/json
X-Tallyfy-Client: APIClient
with
(string): Include related data. For tasks, common options might includerun
,step
,threads
,assets
,form_fields
,tags
,summary
. Example:with=run,step,form_fields
.
const accessToken = 'YOUR_PERSONAL_ACCESS_TOKEN';const orgId = 'YOUR_ORGANIZATION_ID';const taskId = 'TASK_ID_TO_GET'; // ID of the task
const queryParams = '?with=run,step,form_fields,tags'; // Example: get related infoconst apiUrl = `https://go.tallyfy.com/api/organizations/${orgId}/tasks/${taskId}${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 get task ${taskId}:`, data); throw new Error(`HTTP error! status: ${response.status}`); } return data; // Pass successful data along });}).then(data => { console.log(`Successfully retrieved task ${taskId}:`); console.log(JSON.stringify(data, null, 2));}).catch(error => { console.error(`Error getting task ${taskId}:`, 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')task_id = 'TASK_ID_TO_GET'api_url = f'https://go.tallyfy.com/api/organizations/{org_id}/tasks/{task_id}'
headers = { 'Authorization': f'Bearer {access_token}', 'Accept': 'application/json', 'X-Tallyfy-Client': 'APIClient'}
# Optional: Add query parametersparams = { 'with': 'run,step,form_fields,tags' # Example: Include related data}
response = Nonetry: response = requests.get(api_url, headers=headers, params=params) response.raise_for_status() # Raises HTTPError for bad responses (4xx or 5xx)
task_data = response.json() print(f'Successfully retrieved task {task_id}:') print(json.dumps(task_data, indent=4))
except requests.exceptions.HTTPError as http_err: print(f"HTTP error occurred getting task {task_id}: {http_err}") if response is not None: print(f"Response Body: {response.text}")except requests.exceptions.RequestException as req_err: print(f"Request failed getting task {task_id}: {req_err}")except json.JSONDecodeError: print(f"Failed to decode JSON response for task {task_id}") 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 GetTask {
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 taskId = "TASK_ID_TO_GET"; String baseUrl = String.format("https://go.tallyfy.com/api/organizations/%s/tasks/%s", orgId, taskId);
// Optional: Add query parameters Map<String, String> queryParamsMap = new HashMap<>(); queryParamsMap.put("with", "run,step,form_fields");
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 retrieved task " + taskId + ":"); System.out.println(response.body()); // TODO: Consider parsing JSON using Jackson/Gson } else { System.err.println("Failed to get task " + taskId + ". 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" } taskId := "TASK_ID_TO_GET" baseURL := fmt.Sprintf("https://go.tallyfy.com/api/organizations/%s/tasks/%s", orgId, taskId)
// Optional: Add query parameters queryParams := url.Values{} queryParams.Add("with", "run,step,form_fields,tags") // Example
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 get task request for task %s: %v\n", taskId, 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 get task request for task %s: %v\n", taskId, err) return } defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body) if err != nil { fmt.Printf("Error reading get task response body for task %s: %v\n", taskId, err) return }
if resp.StatusCode != http.StatusOK { fmt.Printf("Failed to get task %s. Status: %d\nBody: %s\n", taskId, resp.StatusCode, string(body)) return }
fmt.Printf("Successfully retrieved task %s:\n", taskId) // 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 struct 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> GetTallyfyTask(const utility::string_t& taskId){ 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("tasks")); builder.append_path(taskId); builder.append_query(U("with"), U("run,step,form_fields,tags")); // Example query parameter 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([taskId](http_response response) { utility::string_t taskIdW = taskId; return response.extract_json().then([response, taskIdW](pplx::task<value> task) { try { value const & body = task.get(); if (response.status_code() == status_codes::OK) { std::wcout << L"Successfully retrieved task " << taskIdW << L":\n" << body.serialize() << std::endl; // Access data: body[U("data")][U("title")].as_string(); } else { std::wcerr << L"Failed to get task " << taskIdW << L". Status: " << response.status_code() << L"\nResponse: " << body.serialize() << std::endl; } } catch (const http_exception& e) { std::wcerr << L"HTTP exception during get task: " << e.what() << std::endl; } catch (const std::exception& e) { std::wcerr << L"Exception during get task response handling: " << e.what() << std::endl; } }); });}
int main() { try { GetTallyfyTask(U("TASK_ID_TO_GET")).wait(); // Replace with actual Task ID } 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 TallyfyTaskGetter{ private static readonly HttpClient client = new HttpClient();
public static async Task GetTaskAsync(string taskId) { 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"] = "run,step,form_fields,tags"; // Example string queryString = query.ToString(); var apiUrl = $"https://go.tallyfy.com/api/organizations/{orgId}/tasks/{taskId}?{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 task {taskId}:"); // Pretty print JSON try { using var doc = JsonDocument.Parse(responseBody); Console.WriteLine(JsonSerializer.Serialize(doc.RootElement, new JsonSerializerOptions { WriteIndented = true })); // Access data: doc.RootElement.GetProperty("data").GetProperty("title").GetString(); } catch (JsonException) { Console.WriteLine(responseBody); // Print raw if not valid JSON } } else { Console.WriteLine($"Failed to get task {taskId}. Status: {response.StatusCode}"); Console.WriteLine($"Response: {responseBody}"); } } catch (HttpRequestException e) { Console.WriteLine($"Request Exception getting task {taskId}: {e.Message}"); } catch (Exception ex) { Console.WriteLine($"An unexpected error occurred: {ex.Message}"); } }
// Example Usage: // static async Task Main(string[] args) // { // await GetTaskAsync("TASK_ID_TO_GET"); // }}
A successful request returns a 200 OK
status code and a JSON object containing a data
field. The value of data
is an object representing the requested task with its full details.
{ "data": { "id": "TASK_ID_TO_GET", "increment_id": 1205, "title": "Review Proposal", "summary": "Review the proposal document attached.", "run_id": "run_id_xyz", "step_id": "step_id_123", "status": "active", "task_type": "member", // or "guest" "owners": { ... }, "deadline": "2024-05-25T17:00:00Z", "created_at": "2024-05-20T10:00:00Z", "last_updated": "2024-05-21T11:00:00Z", "position": 1, // ... other task properties ... // Included if requested with 'with=form_fields': "form_fields": [ { "id": "capture_id_abc", "label": "Approval Status", "field_type": "dropdown", "value": { "id": 1, "text": "Approved", "value": null }, // Value depends on field type "required": true // ... other form field details ... } ], // Included if requested with 'with=run': "run": { ... process run details ... }, // Included if requested with 'with=step': "step": { ... template step details ... } }}
If the task ID is not found or you don’t have permission, you will likely receive a 404 Not Found
or 403 Forbidden
error.
The GET endpoint enables retrieval of specific tag details through unique IDs with optional related data inclusion and returns a JSON response containing tag information along with error handling for invalid requests or permissions.
Tasks > List organization tasks
The GET endpoint retrieves and filters tasks across processes within an organization offering extensive customization through query parameters and returns detailed task information with pagination support.
The GET endpoint allows retrieval of task lists associated with a specific process run through authorization headers and optional query parameters for filtering sorting and pagination functionality.
About Tallyfy
- 2025 Tallyfy, Inc.
- Privacy Policy
- Terms of Use
- Report Issue
- Trademarks