A connection is the authenticated link between UnifyApps and the app you want to work with — it holds the credentials that automations, apps, and agents use to reach that app on your behalf. This page walks through the four actions available on a connection: creating one from scratch, editing its details and credentials, cloning it to stand up a near-identical copy, and sharing it so others can use it too.
Overview
Every connection goes through the same basic lifecycle. You create it by picking an app and authenticating against it, either with a key/password or through OAuth. Once it exists, you can edit its name and — when it's inactive — its credentials, clone it to quickly get a second working connection without repeating the authentication step, and share it so teammates can use the same authenticated account instead of setting up their own. Which of these actions you see on a given connection depends on the permissions you've been granted.
Creating a Connection
Creating a connection sets up a brand-new authenticated link to an app so it becomes available to your automations, apps, and agents.
Select New Connection and pick the app you want to connect to. Apps are grouped by category, and you can search across both built-in and custom connectors.
Fill in the connection form: give it a name, choose an authentication method if the app offers more than one (for example OAuth vs. API key), and provide the inputs that method needs — credentials, host or region, scopes. A docs panel next to the form shows the app's own setup instructions as you go.
Confirm the connection. For key or password-style authentication, click Create — the platform tests the credentials against the app first and only saves the connection if that test passes. For OAuth, click Authorize instead, which sends you through the app's own login-and-consent flow; some apps then show a short Confirm OAuth Details step for a few extra inputs.
For key/password-style auth, use Test Connection next to the save action to run the same check without saving — handy for catching a wrong key, a missing scope, or a mistyped host before you commit. OAuth methods don't show this button, since the authorize flow itself is the validation. If authentication fails, an error banner on the form explains what went wrong; re-check your inputs against what the app expects, and for OAuth confirm you approved the requested permissions.
Editing a Connection
Editing lets you update a connection's name or credentials in place, so everything already using it keeps pointing at the same connection with the new details.
Open the connection's Details tab. What you can change depends on its status:
While the connection is Active, only its name, tags, and workspace are editable — the credential fields stay locked because live automations depend on them. Confirm with Save (this reads Re-authorize on OAuth connections, which also re-runs the consent flow).
While it's Inactive, the credential fields unlock too, so you can enter new credentials and click Authorize, or re-run the OAuth flow.
When an app's credentials change — a rotated API key, a new password, a revoked OAuth grant — click Disconnect first if the connection is still Active; this clears the authentication and flips it to Inactive. With it Inactive, re-enter the credentials and authorize again. On success the connection returns to Active without you recreating it or touching anything downstream that uses it. Do this as soon as you know credentials changed, so dependent automations don't start failing in the meantime.
Two things you can't change: the app a connection points to, and — while it's Active — its authentication method. Both are fixed on purpose, since automations rely on the connection's identity staying stable. If you need a different app, create a new connection instead of repurposing this one.
Cloning a Connection
Cloning gives you a fast way to stand up another connection that's almost identical to one you already have, without going through the full create-and-authenticate flow again.
Choose Clone on a connection's row in the connections list. A small dialog opens with a single Name field, pre-filled with the original's name plus a "(clone)" suffix — change it if you like — then confirm with Clone. You land straight on the new connection's edit page: a separate connection you manage independently. Cloning requires permission to create connections.
The clone carries over the original's credentials (so it's usable immediately, without re-authenticating), its authentication method and inputs, its request-throttling settings, and its tags. What it doesn't carry over: its own new identity and a fresh, empty history; who the original was shared with (you become the clone's owner); and any automations or apps that already used the original — those keep using the original until you point them at the clone yourself.
Clone when you want a second connection to the same app for a different team, a copy you'll re-authenticate with a different account, or a starting point that already has the right settings. If you need a genuinely different account, clone and then re-authenticate the copy (disconnecting it first if it's Active); if you need a different app entirely, create a new connection instead.
Sharing a Connection
Sharing gives other people access to a connection you own, so a colleague can use it in their automations or a team can co-manage it — without each person setting up their own authenticated link to the same app.
Choose Share on a connection in the connections list, then add the users or user groups you want to give access to and pick a role for each. Adding a user group grants access to all its members at once. The Share action itself requires share permission on the connection.
Access is granted through roles defined in your organization. A role is made up of connection permissions such as view (see and use the connection), edit (change its name, credentials, and settings), clone, delete, share (manage who else has access), and finer grants like view insights and view settings. Which actions someone sees on a connection — Edit, Clone, Share, Delete — follows directly from these permissions, so grant the least access that does the job: most people only need a view-level role, while edit and share belong to whoever maintains the connection.
To revoke access, open Share on the connection and choose Remove Access from that person's role dropdown. Any of their automations that relied on the connection through that access will stop working, so coordinate before revoking from someone whose work depends on it.
Notes
Clicking Create or Authorize already runs a credentials test, so a saved connection can't have broken credentials — Test Connection is just a way to check as you go.
You must disconnect an Active connection before its credential fields unlock for editing.
A clone shares the same credentials as its original, so both act as the same account on the app until one is re-authenticated separately.
Sharing history and prior access don't carry over when you clone a connection — the clone starts with only you as owner.
Revoking someone's access is immediate and can break their automations, so confirm with them first.