Complete Tallyfy tasks from Workato

Automatically complete Tallyfy tasks using Workato

This guide explains how to complete Tallyfy tasks programmatically from Workato recipes. This enables you to update task progress based on events in other systems, creating seamless cross-platform workflows.

Common use cases

• Mark tasks complete when a document is signed in DocuSign
• Complete approval tasks based on responses in Microsoft Forms
• Update task form fields when data changes in your CRM
• Auto-complete tasks when specific conditions are met in your ERP

Prerequisites

• Workato account with HTTP connector access
• Tallyfy API token from Settings > Integrations > REST API
• Task IDs or a method to retrieve them dynamically
• Understanding of your task’s form fields

Setting up task completion

Step 1: Identify the task to complete

You need the task ID to complete it. There are several ways to obtain this:

Option A: From a Tallyfy webhook

If Tallyfy triggered your Workato recipe via webhook:

task_id = trigger["task"]["id"]

Option B: Search for tasks by process

Use an HTTP GET request to find tasks:

GET https://go.tallyfy.com/api/tasks?run_id={process_id}

Option C: Store task IDs

When launching processes, store the returned task IDs in a lookup table or database for later use.

Step 2: Configure the completion request

1. Add an HTTP action to your Workato recipe
2. Configure the request:
   • Method: PUT
   • URL: https://go.tallyfy.com/api/tasks/{task_id}/complete
   • Headers:
     • Content-Type: application/json
     • X-Tallyfy-Client: APIClient
3. Add the request body with form field data

Step 3: Handle form fields

If the task has form fields that need values, include them in the request body:

{
  "form_fields": {
    "approval_status": "Approved",
    "approver_name": "John Smith",
    "approval_date": "2024-03-15",
    "comments": "Looks good, approved for implementation"
  }
}

Dynamic field mapping

Map fields from your trigger data:

{
  "form_fields": {
    "invoice_number": trigger["invoice"]["number"],
    "amount": trigger["invoice"]["total"],
    "payment_status": trigger["payment"]["status"],
    "processed_by": trigger["user"]["email"]
  }
}

Advanced completion scenarios

Conditional task completion

Only complete tasks when specific conditions are met:

1. Add a conditional action before the HTTP request
2. Check your conditions:

   trigger["order"]["status"] == "shipped" AND
   trigger["order"]["payment_status"] == "paid"

3. Place the completion HTTP action inside the conditional block

Bulk task completion

To complete multiple tasks in a process:

1. First, get all tasks for a process:

   GET https://go.tallyfy.com/api/tasks?run_id={process_id}&status=active

2. Use a For each loop in Workato
3. Inside the loop, complete each task that matches your criteria
4. Add a 1-second delay between completions to avoid rate limits

Updating without completing

To update task form fields without marking the task complete:

PUT https://go.tallyfy.com/api/tasks/{task_id}

Request body:

{
  "captures": {
    "field_name": "updated_value",
    "status": "In Progress"
  }
}

Error handling strategies

Common errors and solutions

Error Code	Meaning	Solution
401	Unauthorized	Check API token and headers
404	Task not found	Verify task ID and that it exists
400	Invalid data	Check form field names and data types
422	Validation failed	Ensure required fields are provided

Implementing retry logic

1. Click the error handler icon on your HTTP action
2. Add a Retry action for transient failures
3. Configure retry settings:
   • Max attempts: 3
   • Interval: 5 seconds
   • Backoff multiplier: 2
4. Add logging for permanent failures

Recipe example: Complete task on document signature

Here’s a complete recipe pattern:

1. Trigger: DocuSign - Document completed
2. Action 1: Search Tallyfy tasks by document ID

   GET https://go.tallyfy.com/api/tasks?search={document_id}

3. Action 2: Parse response to get task ID
4. Action 3: Complete the task with signature details

   {
     "form_fields": {
       "signed_by": "{{trigger.signer_email}}",
       "signed_date": "{{trigger.completed_date}}",
       "document_url": "{{trigger.document_url}}",
       "signature_id": "{{trigger.envelope_id}}"
     }
   }

5. Action 4: Send confirmation email

Best practices

Performance optimization

• Cache frequently used task IDs
• Use batch operations when possible
• Implement connection pooling for high-volume scenarios
• Monitor API usage against rate limits

Data integrity

• Validate data before sending to Tallyfy
• Log all completions for audit trails
• Implement rollback mechanisms for critical workflows
• Use idempotency keys to prevent duplicate completions

Security considerations

• Never expose API tokens in logs
• Use Workato’s secure storage for credentials
• Implement field-level encryption for sensitive data
• Audit recipe access regularly

Troubleshooting guide

Task not completing?

1. Verify the task is in “active” status
2. Check all required form fields are provided
3. Ensure the assigned user has permission
4. Confirm the task hasn’t already been completed

Form data not saving?

1. Field names must match exactly (case-sensitive)
2. Check data types (string vs number vs boolean)
3. Verify field exists in the task template
4. Ensure values meet field validation rules

Getting 429 rate limit errors?

1. Add delays between requests
2. Implement exponential backoff
3. Batch operations where possible
4. Contact Tallyfy support for higher limits if needed

Next steps

• Set up webhooks to trigger completions in real-time
• Create reusable functions for common operations
• Build error notification workflows
• Implement comprehensive logging and monitoring

Related articles

Middleware > Integrate Tallyfy with Workato

Workato integrates with Tallyfy through HTTP connectors or custom connectors to enable enterprise-scale workflow automation between Tallyfy processes and other business systems with robust error handling data transformations and security features.

Workato > Launch Tallyfy processes from Workato

This guide demonstrates how to integrate Workato with Tallyfy to automatically launch processes by configuring HTTP connections setting up API authentication and mapping dynamic data from external systems to trigger workflows through REST API calls.

Zapier > Automate tasks in Tallyfy using zaps

A detailed walkthrough for automating task completion in Tallyfy through integration platforms like Zapier by finding process tasks and marking them complete using middleware solutions or the Open API.

Tasks > Complete task

An API endpoint marks tasks as complete through POST requests requiring task ID with optional approval status and form field values while supporting both process-based and standalone tasks through different URL structures.