Workato > Launch Tallyfy processes from Workato
Integrate Tallyfy with Workato
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.
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.
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
- In Workato, create a new recipe and add an HTTP connector
- 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
- Base URL:
- Add a custom header:
- Header name:
X-Tallyfy-Client
- Header value:
APIClient
- Header name:
- Test the connection using a simple GET request to
/users/me
Here are the most useful Tallyfy API endpoints for Workato recipes:
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" }}
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" }}
HTTP Action Configuration:
- Method: GET
- Endpoint:
/runs/{run_id}
- Headers:
X-Tallyfy-Client: APIClient
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"}
To receive real-time updates from Tallyfy:
- Create a new Workato recipe with a Webhook trigger
- Copy the webhook URL provided by Workato
- 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
- In Workato, parse the incoming webhook data and trigger subsequent actions
For organizations needing a reusable, managed connector, you can build a custom Tallyfy connector using Workato’s Connector SDK.
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 } }}
Add these actions to your custom connector for complete Tallyfy integration:
- List Templates - Get available templates
- Get Process Details - Grab information about a specific process
- Update Task - Change task data or complete tasks
- Create Comment - Add comments to tasks
- Upload File - Attach files to tasks
- Set up retry logic for transient failures
- Use Workato’s error handling features to catch API errors
- Log failed requests for debugging
- Set up alerts for critical integration failures
- 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
- 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
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
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
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”
After setting up your Tallyfy-Workato integration:
- Test thoroughly with sample data
- Document your recipes for team members
- Set up monitoring and alerts
- Consider building a library of reusable recipes
For more support:
- Check out Tallyfy’s API documentation ↗
- Look at Workato’s HTTP connector guide ↗
- Contact Tallyfy support for API questions
Workato > Complete Tallyfy tasks from Workato
- 2025 Tallyfy, Inc.
- Privacy Policy
- Terms of Use
- Report Issue
- Trademarks