Skip to content

Integrate Tallyfy with Workato

How can I connect Tallyfy to Workato for enterprise automation?

Workato is an enterprise-grade integration platform built for complex, large-scale business workflows. Think of it as the Swiss Army knife of business automation - powerful enough for Fortune 500 companies but flexible enough to adapt to your needs.

Here’s the thing: Workato doesn’t have a pre-built Tallyfy connector yet. But you can still integrate Tallyfy using Workato’s HTTP connector or by building a custom connector (it’s easier than it sounds).

Why should I choose Workato for Tallyfy integration?

Workato brings real value to enterprise Tallyfy integrations with:

  • Enterprise-scale integrations with solid error handling and monitoring
  • Complex data transformations between systems
  • Multi-step workflows that involve multiple applications
  • Advanced security features including encryption and compliance tools
  • Recipe versioning and deployment across environments

Common Tallyfy integration scenarios include:

  • Synchronizing Tallyfy processes with enterprise ERP systems
  • Automating task creation from CRM opportunities
  • Integrating Tallyfy with HR systems for employee onboarding
  • Connecting Tallyfy to financial systems for approval workflows

The HTTP connector gets you up and running in about 15 minutes. No custom code needed.

Prerequisites

Before starting, make sure you have:

  • A Workato account with access to HTTP connectors
  • A Tallyfy account with API access
  • Your Tallyfy API token (find it in Settings > Integrations > REST API)
  • Your Tallyfy Organization ID

Setting up the HTTP connection

  1. In Workato, create a new recipe and add an HTTP connector
  2. Set up the connection with these settings:
    • Base URL: https://go.tallyfy.com/api/
    • Authentication type: API key
    • Authentication method: Header authentication
    • Header name: Authorization
    • Header value: Bearer YOUR_TALLYFY_API_TOKEN
  3. Add a custom header:
    • Header name: X-Tallyfy-Client
    • Header value: APIClient
  4. Test the connection using a simple GET request to /users/me

Common Tallyfy API operations in Workato

You’ll use these Tallyfy API endpoints most often in your Workato recipes:

Launching a process

HTTP Action Configuration:

  • Method: POST
  • Endpoint: /runs
  • Headers:
    • Content-Type: application/json
    • X-Tallyfy-Client: APIClient
  • Body (JSON):
{
  "blueprint_id": "YOUR_TEMPLATE_ID",
  "title": "Process Title",
  "owner_id": "USER_ID",
  "prerun": {
    "field_name": "field_value"
  }
}

Completing a task

HTTP Action Configuration:

  • Method: PUT
  • Endpoint: /tasks/{task_id}/complete
  • Headers:
    • Content-Type: application/json
    • X-Tallyfy-Client: APIClient
  • Body (JSON):
{
  "form_fields": {
    "field_name": "field_value"
  }
}

Retrieving process information

HTTP Action Configuration:

  • Method: GET
  • Endpoint: /runs/{run_id}
  • Headers:
    • X-Tallyfy-Client: APIClient

Creating a task comment

HTTP Action Configuration:

  • Method: POST
  • Endpoint: /tasks/{task_id}/comments
  • Headers:
    • Content-Type: application/json
    • X-Tallyfy-Client: APIClient
  • Body (JSON):
{
  "comment": "Your comment text here"
}

Handling Tallyfy webhooks in Workato

To receive real-time updates from Tallyfy:

  1. Create a new Workato recipe with a Webhook trigger
  2. Copy the webhook URL provided by Workato
  3. In Tallyfy, configure the webhook in your template:
    • Go to the template editor
    • Add a webhook action to the relevant step
    • Paste the Workato webhook URL
    • Configure the payload data you want to send
  4. In Workato, parse the incoming webhook data and trigger subsequent actions

Method 2: Building a custom Tallyfy connector

Want a reusable connector your whole team can use? Build a custom Tallyfy connector with Workato’s Connector SDK.

Basic connector structure

Here’s a basic template for a Tallyfy custom connector:

{
  title: "Tallyfy",


  connection: {
    fields: [
      {
        name: "api_token",
        label: "API Token",
        optional: false,
        control_type: "password",
        hint: "Found in Settings > Integrations > REST API"
      },
      {
        name: "organization_id",
        label: "Organization ID",
        optional: false,
        hint: "Your Tallyfy Organization ID"
      }
    ],


    authorization: {
      type: "custom_auth",


      apply: lambda do |connection|
        headers(
          "Authorization": "Bearer #{connection['api_token']}",
          "X-Tallyfy-Client": "APIClient",
          "Content-Type": "application/json"
        )
      end
    },


    base_uri: lambda do |connection|
      "https://go.tallyfy.com/api"
    end
  },


  test: lambda do |connection|
    get("/users/me")
  end,


  actions: {
    launch_process: {
      title: "Launch a Process",


      input_fields: lambda do
        [
          { name: "blueprint_id", label: "Template ID", optional: false },
          { name: "title", label: "Process Title", optional: false },
          { name: "owner_id", label: "Owner User ID", optional: false }
        ]
      end,


      execute: lambda do |connection, input|
        post("/runs", input)
      end,


      output_fields: lambda do |object_definitions|
        [
          { name: "id", label: "Process ID" },
          { name: "title", label: "Process Title" },
          { name: "status", label: "Status" }
        ]
      end
    }
  }
}

Implementing common actions

These five actions cover 90% of what you’ll need in a Tallyfy connector:

  1. List Templates - Get available templates
  2. Get Process Details - Grab information about a specific process
  3. Update Task - Change task data or complete tasks
  4. Create Comment - Add comments to tasks
  5. Upload File - Attach files to tasks

Best practices for Workato-Tallyfy integration

Error handling

  1. Set up retry logic for transient failures
  2. Use Workato’s error handling features to catch API errors
  3. Log failed requests for debugging
  4. Set up alerts for critical integration failures

Performance optimization

  • Batch operations when possible to reduce API calls
  • Cache frequently used data like user IDs and template IDs
  • Use webhooks instead of polling for real-time updates
  • Set up pagination when retrieving large datasets

Security considerations

  • Store API tokens securely in Workato’s connection management
  • Use Workato’s role-based access control for recipe management
  • Regularly rotate API tokens
  • Monitor API usage to catch unusual patterns

Troubleshooting common issues

Authentication errors

Getting 401 errors? Here’s what to check:

  • Check that your API token is correct and active
  • Make sure the X-Tallyfy-Client: APIClient header is included
  • Verify that your bearer token format is exactly Bearer YOUR_TOKEN

Rate limiting

Tallyfy’s rate limits are pretty generous:

  • 100 requests per minute per organization
  • 1,000 requests per hour per organization

Avoid hitting these limits by:

  • Setting up exponential backoff
  • Using bulk operations where available
  • Tracking your API usage in recipe insights

Data mapping issues

The API and UI use different terms - watch out for these:

  • API “blueprints” = UI “templates”
  • API “runs” = UI “processes”
  • API “captures” = UI “form fields”

Next steps

You’ve got your integration working - what’s next?

  1. Test everything with sample data first
  2. Document your recipes (your future self will thank you)
  3. Set up monitoring and alerts
  4. Build a library of reusable recipes

Need help?

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.

N8N > Connect n8n to Tallyfy

The guide explains connecting n8n to Tallyfy in 5 minutes using either a dedicated community-built connector for instant setup or HTTP Request nodes for maximum flexibility with both approaches supporting Tallyfy’s Open API and seamless authentication.

Workato > Complete Tallyfy tasks from Workato

This guide demonstrates how to programmatically complete Tallyfy tasks from Workato recipes by using HTTP requests with task IDs and form field data to create automated cross-platform workflows triggered by external system events.

Integrations > Middleware

Middleware platforms like Zapier Make and Power Automate enable non-technical users to automatically connect Tallyfy with other business applications through visual drag-and-drop interfaces without requiring any coding expertise.
Get in touch
About Tallyfy