Skip to content
Tallyfy

Launch Tallyfy processes from Workato

Launch Tallyfy processes from Workato recipes

You can connect Workato to Tallyfy’s API so that events in Salesforce, Zendesk, or any other system automatically start processes. Workato’s HTTP connector sends a POST request to Tallyfy with your template ID and kick-off form data - no custom code needed.

How the integration flows

Diagram

Key points:

  • Authentication (step 4) needs a Bearer token and the X-Tallyfy-Client header - missing either causes a 401 error
  • Workato maps your trigger data into the prerun object, which populates kick-off form fields automatically (step 2)
  • Error handling (step 8) catches authentication failures, bad template IDs, or data format issues

Prerequisites

You’ll need:

  • A Workato account with HTTP connector access
  • A Tallyfy account with API access
  • Your Tallyfy API token from Settings > Integrations > REST API
  • Your organization ID (found in Settings > Organization)
  • The template ID for the process you want to launch

Step 1 - Create the HTTP connection in Workato

  1. In Workato, go to Connections and click Create connection
  2. Search for and select HTTP
  3. Name your connection (e.g., “Tallyfy API”)
  4. Configure these settings:
    • Authentication type: API key
    • How to apply: Header
    • Authorization header format: Custom
    • Custom authorization header: Bearer YOUR_API_TOKEN
    • Other headers: Click Add header and add:
      • Name: X-Tallyfy-Client
      • Value: APIClient
  5. Click Connect to save

Step 2 - Create a recipe to launch processes

  1. Create a new recipe in Workato
  2. Choose your trigger (e.g., “New row in database”, “New Salesforce opportunity”)
  3. Add an HTTP action
  4. Select your Tallyfy HTTP connection
  5. Configure the HTTP request:
    • Request name: Launch Tallyfy Process
    • Method: POST
    • URL: https://go.tallyfy.com/api/organizations/YOUR_ORG_ID/runs
    • Request headers: Add Content-Type with value application/json

The URL includes your organization ID as a path segment. Don’t pass organization_id in the request body - it belongs in the URL.

Step 3 - Configure the request body

Add this JSON to the Request body field:

{
  "checklist_id": "YOUR_TEMPLATE_ID",
  "name": "Process name from trigger data",
  "owner_id": "USER_ID",
  "prerun": {
    "field1_name": "value from trigger",
    "field2_name": "another value"
  }
}

The checklist_id is the template’s timeline ID (what the API calls a “blueprint” internally). The name field sets the process title. The owner_id is optional - if omitted, the authenticated user becomes the owner.

Mapping dynamic data

Instead of hardcoding values, use Workato’s Formula mode:

  1. Click the Formula mode toggle
  2. Build your JSON dynamically:
{
  "checklist_id": "abc123",
  "name": "Order " + trigger["order_number"] + " - " + trigger["customer_name"],
  "owner_id": "user456",
  "prerun": {
    "customer_name": trigger["customer_name"],
    "order_value": trigger["total_amount"],
    "priority": trigger["priority"]
  }
}

Step 4 - Handle kick-off form fields

If your template has a kick-off form, populate those fields through the prerun object:

  1. Check which kick-off form fields are required in your template
  2. Map each field in the prerun section
  3. Match data types (text, number, date, etc.)

Here’s an example with different field types:

{
  "checklist_id": "template123",
  "name": "New Employee: John Smith",
  "owner_id": "hr_manager_id",
  "prerun": {
    "employee_name": "John Smith",
    "start_date": "2026-03-15",
    "department": "Engineering",
    "salary": 75000,
    "remote_worker": true
  }
}

Step 5 - Use the Tallyfy response

Tallyfy returns the created process details. You can capture these in your recipe:

  1. Add a Variable action after your HTTP request
  2. Name it “Process Details”
  3. Map fields from the HTTP response:
    • id - The process ID
    • name - The process name
    • created_at - When it was created

Step 6 - Add error handling

  1. Click the HTTP action’s error handler
  2. Add actions for different error scenarios:
    • 401 Unauthorized: Token expired or missing headers
    • 404 Not Found: Template ID doesn’t exist
    • 422 Unprocessable Entity: Validation errors (missing required fields, bad data types)
  3. Add email notifications for failures so you catch problems early

Common integration patterns

Launch from a CRM opportunity

When a Salesforce opportunity hits “Closed Won,” onboarding starts automatically:

  1. Trigger: Salesforce - Updated opportunity
  2. Condition: Status changed to “Closed Won”
  3. Action: Launch Tallyfy customer onboarding process
  4. Pass opportunity data to kick-off form

Launch from a support ticket

Route urgent tickets into a structured escalation process:

  1. Trigger: Zendesk - New ticket
  2. Condition: Priority = “Urgent”
  3. Action: Launch Tallyfy escalation process

Scheduled launches

Run recurring processes on a schedule:

  1. Trigger: Scheduler - Daily/Weekly/Monthly
  2. Action: Launch Tallyfy process
  3. Use date formulas for dynamic names

Troubleshooting

Process won’t launch?

  • Confirm your API token is active and hasn’t expired
  • Check that the X-Tallyfy-Client: APIClient header is included
  • Verify the template ID is the timeline ID, not the template name
  • Make sure the org ID in your URL is correct

Kick-off form data not appearing?

  • Field names in prerun must match exactly (they’re case-sensitive)
  • Data types need to match field expectations
  • Required fields can’t be empty

Getting 422 validation errors?

The API returns detailed validation errors. Check the response body for a details object that tells you which fields failed and why.

Middleware > Workato

Tallyfy’s Workato connector lets you automate workflows between Tallyfy and enterprise systems like Salesforce, SAP, and Workday through OAuth 2.0 authentication with built-in actions for launching processes, completing tasks, and polling triggers for new assignments.

Triggers > Launch via middleware

Middleware platforms like Zapier and Make.com let you automatically launch Tallyfy processes from events in other apps—such as form submissions or new CRM records—by watching for triggers and passing mapped data into Tallyfy kick-off forms without any custom coding.

Triggers > Launch via API

Tallyfy’s REST API lets you programmatically launch processes by sending a POST request with a template ID and optional pre-filled data so that external events like CRM deal closures or form submissions can automatically kick off tracked workflows with custom names and assignments and deadlines.

Postman > Working with templates and processes

Working with Tallyfy templates and processes through the API in Postman requires understanding that the API uses “checklists” for templates and “runs” for processes, with process creation done via POST to the runs endpoint with a checklist_id in the request body.
Get in touch
About Tallyfy