Ticketing
Make
API integration
Ship Ticketing features without building the integration. Full Make API access via Proxy, normalized data through Unified APIs — extend models and mappings to fit your product.
Talk to usUse Cases
Why integrate with Make
Common scenarios for SaaS companies building Make integrations for their customers.
Synchronize workspace teams and user roles with Make organizations
A B2B SaaS can automatically mirror its internal teams, groups, and user roles into the customer's Make Organization, ensuring that when support groups change in the SaaS, the corresponding Make Teams and user permissions stay in sync without manual effort.
Automate Make workspace provisioning for new customers
When a new company signs up for your ticketing platform, automatically provision a dedicated Make Team within their Organization and invite the right users — eliminating onboarding friction and letting customers start building automations from day one.
Enable departmental directory synchronization for enterprise accounts
Enterprise customers expect their org structures to be consistent across tools. By syncing groups and users from your SaaS into Make's organizational hierarchy via Truto, you prevent permission drift and reduce IT admin overhead.
Offer a native automation layer without building it from scratch
Instead of building a proprietary automation engine, SaaS companies can embed Make as their extensibility platform, using Truto to manage the connection lifecycle — auth, token refresh, and user directory mapping — so end users can wire up complex workflows against your product.
What You Can Build
Ship these features with Truto + Make
Concrete product features your team can ship faster by leveraging Truto’s Make integration instead of building from scratch.
Automatic Make Team provisioning on group creation
When an admin creates a new support group in your product, automatically create a mirrored Team in the customer's Make Organization with the same members and permissions.
User directory sync dashboard
Display a real-time view of which users and groups in your product are mapped to Make Organizations, Teams, and Users, letting admins audit and troubleshoot access in one place.
Role-based access control (RBAC) mirroring
Map your product's role hierarchy to Make's organizational user roles so that permission changes propagate automatically, keeping both systems consistent.
One-click Make account connection via embedded auth
Let end users securely connect their Make account from inside your product UI using Truto's managed auth flow, handling OAuth tokens and refresh cycles transparently.
Organization-level onboarding automation
Automatically read the customer's existing Make Organization structure — teams, users, and groups — and pre-map them to your product's entities during initial setup.
Unified APIs
Unified APIs for Make
Skip writing code for every integration. Use Truto’s category-specific Unified APIs out of the box or customize the mappings with AI.
Unified User Directory API
Groups
Groups are a collection of users in the source application. In some applications, they might also be called Teams.
Organizations
Organizations are the top level entity in the source application. Users are associated with an organization.
Users
The User object represents a User.
How It Works
From zero to integrated
Go live with Make in under an hour. No boilerplate, no maintenance burden.
Link your customer’s Make account
Use Truto’s frontend SDK to connect your customer’s Make account. We handle all OAuth and API key flows — you don’t need to create the OAuth app.
We handle authentication
Don’t spend time refreshing access tokens or figuring out secure storage. We handle it and inject credentials into every API request.
Call our API, we call Make
Truto’s Proxy API is a 1-to-1 mapping of the Make API. You call us, we call Make, and pass the response back in the same cycle.
Unified response format
Every response follows a single format across all integrations. We translate Make’s pagination into unified cursor-based pagination. Data is always in the result attribute.
FAQs
Common questions about Make on Truto
Authentication, rate limits, data freshness, and everything else you need to know before you integrate.
What data can I access from Make through Truto today?
Truto's Unified User Directory API maps to Make's Organizations, Teams (Groups), and Users. This lets you read and manage workspace structures, team membership, and user details. Additional Make-specific tools (e.g., Scenarios, Execution Logs) are not yet available as standard tools but can be built on request.
How does authentication work for connecting a customer's Make account?
Make uses OAuth 2.0 for API access. Truto manages the full auth lifecycle — token issuance, storage, and automatic refresh — so your application never handles raw credentials and your end users get a seamless connect experience.
Can I access Make Scenarios or execution logs through Truto?
Not out of the box. The current integration covers the Unified User Directory API (Organizations, Groups, Users). Support for Scenarios, execution logs, and other Make-specific endpoints can be built on request by the Truto team.
How does Truto handle Make's API rate limits?
Truto manages pagination and respects Make's rate limiting policies automatically, retrying where appropriate. Your application interacts with Truto's unified endpoint and doesn't need to implement rate-limit handling logic directly.
What does 'built on request' mean for Make-specific tools?
It means that while the Unified User Directory API is available now, any Make-specific endpoints beyond Organizations, Groups, and Users — such as Scenarios, Connections, or Templates — can be added by Truto's team based on your requirements, typically with a fast turnaround.
Can I write data back to Make, or is this read-only?
The Unified User Directory API supports both read and write operations where the underlying Make API permits it. You can create teams, invite users, and update group memberships programmatically. Exact write capabilities depend on Make's API permissions and your OAuth scopes.
From the Blog
Make integration guides
Deep dives, architecture guides, and practical tutorials for building Make integrations.
Make
Get Make integrated into your app
Our team understands what it takes to make a Make integration successful. A short, crisp 30 minute call with folks who understand the problem.
Talk to us