Make Integration

Use Make scenarios to move Keito records between your team’s tools without writing an integration. You can watch for new records, search before creating them, and build time, expense, and invoice workflows.

Availability: controlled beta. Make review is pending. The connector is not yet a public Make directory listing. Contact Keito support for beta access and installation instructions. Your workspace must be enabled by Keito; plan and subscription eligibility also apply. Being able to sign in does not by itself enable Make access.

For request schemas and developer details, see the Make API guide and OpenAPI specification. Module help in your Make editor describes each field.

Connect your workspace

Get beta access and the installation instructions from Keito support, then add a Keito module to a Make scenario.
Select Add beside Connection. Sign in to Keito as the person whose permissions the scenario should use and authorize access.
Leave Workspace ID (optional) in advanced settings empty to use your active Keito workspace. To choose another workspace you belong to, copy its Company ID from Settings > API & Developers > Company ID in Keito and paste it into that field.
Test a read module first, such as Search Clients, using a known record. Check that the connection identifies the intended workspace before turning on the scenario.

Each connection stays pinned to one workspace. Switching your active workspace in Keito does not move it; create a separate connection for each workspace. Make manages OAuth token refresh, so you do not paste an API key into this connection.

Members of your Make team may use a shared connection in their scenarios. Actions run as the Keito person who connected it and use that person’s current permissions. Choose an account whose access you intend to share. An administrator connection can expose financial actions to that Make team; a connection never grants permissions the Keito user does not have.

Choose a module

Scheduled triggers

Module	What it watches
Watch New Clients	Newly created clients
Watch New Contacts	Newly created client contacts; optional client filter
Watch New Projects	Newly created projects; optional client filter and assigned-people enrichment
Watch New Time Entries	Newly created time entries; optional project and user filters (`me` means the connected user), plus client/contact/recipient enrichment
Watch New Expenses	Newly created expenses; optional project and client filters
Watch New Invoices	Newly created invoices; optional state and client filters
Watch Updated Invoices	Invoice updates; optional client filter

These triggers poll on your Make schedule. They are not instant webhooks. Updated invoices emit the latest invoice state, so several changes between runs can become one bundle. The invoice keeps its canonical id; event_id combines that ID and updated_at to identify the update.

Choose From now on, Since a specific date, or All when setting the starting point. Each scan excludes the most recent 30 seconds to allow records to settle. Limit controls the bundles emitted per run (1–300, default 100), rather than the number of records counted in the pending window.

A window over 3,000 matching records stops with poll_backlog_exceeded before emitting bundles or advancing the checkpoint. Narrow the filters or arrange a separate export/backfill, preserving the last safe boundary shown in the error. Restarting from From now on skips older records. During beta, verify your scenario’s output and recovery behavior before relying on it for billing or a historical migration.

Create and update actions

Module	Result	Idempotency key
Create a Client	A client	Optional
Create a Contact	A client contact	Optional
Create a Project	A project from scratch or a saved template	Optional
Create a Project Task	A workspace task	Optional
Add a Task to a Project	A project task assignment	Optional
Set a Task Budget	Updates an existing assignment’s budget, rate, or billable flag	Optional
Create a Time Entry	A time entry using hours or start/end values	Optional; recommended
Create an Expense	An expense using total cost or units	Required
Create an Estimate	A draft estimate	Required
Create an Invoice	A draft invoice	Required
Send an Invoice Message	Sends, reminds, or thanks the recipient	Required

Create related clients, projects, and tasks first, or map their IDs from earlier modules. A project template supplies its billing, budget, tasks, and people; the module’s corresponding manual fields are ignored when a template is selected.

Send an Invoice Message sends real email. Use addresses you control while testing. Send issues a draft invoice and assigns its final number; Reminder requires an open invoice and Thank You requires a paid invoice. Sending can also trigger your workspace’s accounting synchronization. Inspect the invoice before retrying a delivery failure: issuance may have succeeded even when email delivery failed.

Search and find or create

Search Clients, Search Projects, and Search Tasks search active records by name. Matches ignore case and surrounding spaces; contains matching is the default, with exact matches first. Enable Exact name only to restrict the result. Search Invoices matches the final invoice number; Search Contacts matches email within a client.

Search modules return one bundle per match and zero bundles for no match. Downstream modules run once per bundle, so set a suitable limit and handle an empty result deliberately.

Find or Create a Client, Project, Contact, or Invoice returns one bundle with created, matched_by, and entity. Name-based modules use exact matching by default; their optional partial mode still refuses multiple matches. Contact matching uses client and email; invoice matching uses the final invoice number. Two matches produce ambiguous_match. No match with Create if missing off produces not_found. All four modules require a stable idempotency key for the create branch. They do not enforce record uniqueness across separate scenarios.

Find or Create an Invoice creates a draft without the searched final number. A later search for that number will not find the draft. Store the returned entity.id for follow-up work, and do not use a fresh key to repeat the creation.

Optional enrichment and pickers

Time-entry triggers can include the client, client contacts, and invoice recipients. These switches are off by default. Contact and recipient enrichment requires contact-view permission; a denied request fails rather than returning a misleading empty list. Invoice recipients include only contacts marked as recipients with a nonblank email, excluding CC/BCC-only contacts. Project triggers can include assigned people; their email is null when the connected user cannot list users.

Dropdowns are bounded. Clients and projects show up to 2,000 active records, project templates and invoices up to 1,000, workspace tasks up to 200, and expenses the newest 200. In actions and searches, switch a field to map mode and supply a known ID when a record is missing. Trigger filters cannot map an ID; leave the filter empty and filter later in the scenario if necessary.

Make an API Call

Use a relative path such as /clients, with query parameters in the module’s query fields. The connection adds authentication and the workspace automatically. Only the server’s supported Make routes and methods are available; this module does not unlock the whole API. It returns statusCode, headers, and body. A rejected local request returns statusCode: 0 and request_rejected without sending a request. Redirects are returned without being followed. See the supported routes.

Keep retries safe

Map an Idempotency key that stays the same for the same source event and action, for example order_12345_create_invoice. Use different keys for distinct actions. Keys contain 8–255 letters, digits, dots, underscores, or hyphens.

Keito retains a completed result for 24 hours. An identical retry with the same key replays that result, subject to current authorization. A changed request with the same key conflicts. After the retention window, the key is no longer duplicate protection. Repeating an ordinary Create without a key can create another record; names and contact email addresses are not unique.

On a conflict, inspect the existing record and execution before doing anything else. Never change the key just to force a retry. An unresolved old claim needs reconciliation; create a new operation only after confirming that the previous one did not commit. More detail is in API idempotency.

Pause or disconnect

Open Settings > Integrations > Make in Keito to manage connections. Owners and administrators can pause Make for the workspace with a reason and resume it later. Pausing keeps connections; requests are refused while paused.

Disconnecting in Keito, or deleting the connection in Make, revokes its local authorization. Connections sharing that OAuth consent can also be revoked. Keito requests revocation of the provider grant when no active Make connection for that user and client remains. Reauthorize to connect again. Removing a person’s active workspace membership also blocks their access. Disconnecting keeps your Keito records and does not disconnect other integration providers.

Troubleshooting

Symptom	Next step
Beta not enabled, rollout off, or plan/subscription refusal	Contact your workspace administrator or Keito support. Reconnecting does not enable access.
No workspace or inactive user	Finish account setup or ask an administrator to restore access.
Workspace paused	Ask an owner or administrator to resume Make in Keito.
Connection revoked or token no longer valid	Reauthorize after checking the user and workspace still have access.
`workspace_mismatch`	Create a separate connection for the intended workspace.
`make_connection_limit`	Disconnect an unused connection; the limit is ten active connections per user and OAuth client.
Permission error or `contacts_not_visible`	Use an authorized user or turn off the optional enrichment. Reconnecting cannot elevate permissions.
`poll_backlog_exceeded`	Preserve the safe boundary, narrow filters, or backfill separately. Do not skip history by resetting the start point.
`ambiguous_match` / `not_found`	Resolve duplicate matches, refine the search, or review Create if missing.
`409` idempotency conflict or unresolved claim	Inspect the earlier action and Keito record; keep the original key while reconciling.
`make_writes_disabled`	Keito has temporarily paused writes. Reads remain available; wait before retrying the same operation.
`make_route_not_allowed` / `request_rejected`	Check the relative path, method, and supported routes. Do not override connection headers.
`429` or a temporary server error	Respect retry delays and reduce request frequency; retain the same key for mutation retries.
`412` configuration error	Contact Keito support; the environment is not configured for Make.

For help, contact Keito support with the module name, error message, run time, and a sanitized execution log. Include the idempotency key for an uncertain write. Never include access tokens, refresh tokens, connection binding keys, or private customer payloads. Keito support cannot directly inspect your Make scenario or execution history.