Complete Tallyfy tasks from Workato

Automatically complete Tallyfy tasks using Workato

Want to complete Tallyfy tasks programmatically from your Workato recipes? You can trigger task updates based on events in other systems - perfect for creating seamless cross-platform workflows.

Common use cases

• Mark Tallyfy tasks complete when a document is signed in DocuSign
• Complete approval tasks based on responses in Microsoft Forms
• Update Tallyfy 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 Tallyfy task to complete

You’ll need the task ID to complete it. Here’s how to get it:

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. Works great for recurring workflows.

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

Need to complete tasks only when specific conditions are met? Easy.

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

Got multiple tasks to complete in a process? Here’s the pattern:

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

Sometimes you just want to update form fields without marking the task complete - maybe you’re collecting data incrementally:

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

Let’s walk through a real-world 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 (saves 200ms per request)
• 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

Tallyfy task not completing?

Here’s the troubleshooting checklist:

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?

The culprit is usually one of these:

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?

You’re hitting our API too fast. Fix it with:

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

Ready to level up your integration? Consider these improvements:

• Set up Tallyfy 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

Organizations can seamlessly integrate Tallyfy with Workato using HTTP connectors or custom connector development to enable enterprise-scale workflow automation between Tallyfy processes and other business systems.

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

Automating task completion in Tallyfy through Zapier integration involves finding the target process task by template and search criteria then marking it complete using the process and task IDs to eliminate manual intervention and accelerate workflow execution.

Postman > Task operations and automation

The Tallyfy API enables comprehensive task management through endpoints for listing tasks by status or assignee completing tasks with form data handling file attachments managing assignments and implementing automation patterns like bulk operations conditional completion and escalation workflows.