Get task

Endpoint

GET /organizations/{org_id}/tasks/{task_id}

This endpoint retrieves the full details for a single Tallyfy task (either a one-off task or a task within a process run) identified by its unique ID.

Request

Replace {org_id} with your Organization ID and {task_id} with the specific ID of the task you want to retrieve.

Headers

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

Query parameters (optional)

• with (string): Include related data. For tasks, common options might include run, step, threads, assets, form_fields, tags, summary. Example: with=run,step,form_fields.

Code samples

Javascript

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 info
const 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);
});

Python

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')
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 parameters
params = {
    'with': 'run,step,form_fields,tags' # Example: Include related data
}

response = None
try:
    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}")

Java

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 map
import 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();
        }
    }
}

Go

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
}

C++

#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)

C#

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");
    // }
}

Response

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": "YYYY-MM-DDTHH:MM:SSZ",
    "created_at": "YYYY-MM-DDTHH:MM:SSZ",
    "last_updated": "YYYY-MM-DDTHH:MM:SSZ",
    "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.

---

Related articles

Processes > Get process

This API endpoint retrieves complete details about a specific Tallyfy process run using its unique ID and supports optional query parameters to include related data like tasks and form field values along with a special next_task parameter that returns the first visible incomplete task in the process.

Tags > Get tag

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.

Tasks > List process tasks

This endpoint retrieves all tasks belonging to a specific process run by providing the organization ID and run ID with optional query parameters for filtering by status owners deadlines and sorting while returning paginated results containing task details like title position status and related step information.

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?

YesNo