Skip to content

Integrate Tallyfy with Workato

How can I connect Tallyfy to Workato for enterprise automation?

Workato represents an enterprise-grade integration and workflow automation platform specifically built for complex, large-scale business integrations and sophisticated workflow orchestration.

While Workato doesn’t currently offer a pre-built Tallyfy connector, organizations can seamlessly integrate Tallyfy using Workato’s robust HTTP connector capabilities or by developing custom connector solutions tailored to specific business requirements.

Why should I choose Workato for Tallyfy integration?

Workato provides exceptional value for enterprise Tallyfy integrations through:

  • 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 is the quickest way to integrate Tallyfy with Workato, requiring no custom code.

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 (gotten from 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

Here are the most useful Tallyfy API endpoints for 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

For organizations needing a reusable, managed connector, you can build a custom Tallyfy connector using 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

Add these actions to your custom connector for complete Tallyfy integration:

  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 cut down 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 spot unusual patterns

Troubleshooting common issues

Authentication errors

If you get 401 errors:

  • 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 enforces rate limits of:

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

To manage rate limits in Workato:

  • Set up exponential backoff
  • Use bulk operations where available
  • Track your API usage in recipe insights

Data mapping issues

When mapping data between systems:

  • Remember that Tallyfy’s API uses different terminology than the UI
  • API “blueprints” = UI “templates”
  • API “runs” = UI “processes”
  • API “captures” = UI “form fields”

Next steps

After setting up your Tallyfy-Workato integration:

  1. Test thoroughly with sample data
  2. Document your recipes for team members
  3. Set up monitoring and alerts
  4. Consider building a library of reusable recipes

For more support:

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.

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.

N8N > Connect n8n to Tallyfy

This guide demonstrates establishing robust connections between n8n and Tallyfy using HTTP Request nodes and API credentials to enable seamless workflow automation including process launching webhook handling and troubleshooting common integration issues.

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