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 engineered for complex, large-scale business integrations and sophisticated workflow orchestration.

While Workato doesn’t currently provide 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 delivers exceptional value for enterprise Tallyfy integrations through:

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

Common 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 fastest way to integrate Tallyfy with Workato, requiring no custom code.

Prerequisites

Before starting, ensure you have:

  • A Workato account with access to HTTP connectors
  • A Tallyfy account with API access
  • Your Tallyfy API token (obtained 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. Configure 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 requiring a reusable, managed connector, you can build a custom Tallyfy connector using Workato’s Connector SDK.

Basic connector structure

Here’s a starter 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 comprehensive Tallyfy integration:

  1. List Templates - Retrieve available templates
  2. Get Process Details - Fetch information about a specific process
  3. Update Task - Modify 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. Implement 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
  • Implement 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 detect unusual patterns

Troubleshooting common issues

Authentication errors

If you receive 401 errors:

  • Verify your API token is correct and active
  • Ensure the X-Tallyfy-Client: APIClient header is included
  • Check 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 handle rate limits in Workato:

  • Implement exponential backoff
  • Use bulk operations where available
  • Monitor your API usage in recipe insights

Data mapping issues

When mapping data between systems:

  • Be aware 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 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 additional 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.

N8N > Connect n8n to Tallyfy

This comprehensive guide demonstrates how to establish robust connections between n8n and Tallyfy using HTTP Request nodes and API integration to enable seamless workflow automation between both platforms.

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 seamless no-code integration between Tallyfy and other business applications through visual workflow builders and automated data synchronization.
Get in touch
About Tallyfy