@devries-cameron20 / composio Mirror · read-only / commits / a2b355d19
Fork 0

Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

Mirrored from https://github.com/Camo67/composio.git

Synced Nov 21, 06:00 UTC

docs: add guide for moving from a managed app to your own OAuth app

Rewrite the managed vs custom auth page as a decision page: what a Composio-managed app gives you, what it limits, and when to move to your own app before you scale. Add a migration guide covering app registration, a custom auth config, per-user session routing while both configs run, reconnecting users, recreating triggers, and retiring managed connections. Point the white-labeling switching section at it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Jeevesh Jain committed Nov 11, 2026 at 16:44 UTC a2b355d19ae929e3b55ddd434cfaec51c7a029e0
6 files changed +350 -26
docs/content/docs/authentication/custom-app-vs-managed-app.mdx
+31 -21
@@ -6,37 +6,44 @@ keywords: [custom auth config, managed auth, oauth, auth config, white label, ow
6
7 Composio supports two ways to authenticate users with toolkits.
8
9 -- **[Composio managed apps](/toolkits/managed-auth)**: Composio registers and maintains OAuth apps for popular toolkits such as GitHub, Gmail, and Slack. You do not need to register your own OAuth app.
9 +- **[Composio-managed apps](/toolkits/managed-auth)**: Composio registers and maintains OAuth apps for popular toolkits such as GitHub, Gmail, and Slack. You don't register an OAuth app.
10 - **Custom auth configs**: You provide your own OAuth app, API key, bearer token, or other credentials and tell Composio to use them for a toolkit.
11
12 -This page covers when to use each, how to create a custom auth config, and how to wire it into a session.
12 +A Composio-managed app works in production, but it isn't built for production scale. Move to your own app before you scale.
13
14 Both options use Composio to store and refresh connected-account credentials. Choosing your own OAuth app changes app ownership, branding, scopes, and provider quota, not [token custody](/docs/security/token-custody#oauth-app-ownership-and-token-custody).
15
16 -## When to use Composio managed apps
16 +## What a managed app gives you
17
18 -Managed apps are the default when they are available. Keep them in production when their consent branding, scopes, and shared provider quotas fit your product. Use them when:
18 +- **No app registration.** You skip the provider's developer portal, client credentials, redirect URIs, and app review.
19 +- **A fast start.** Create a session and connect a test account right away. Composio requests a default set of scopes for each toolkit.
20
20 -- **You're building and iterating.** No OAuth app registration, no credentials to manage. Create a session and start testing immediately.
21 -- **Default scopes cover your needs.** Composio requests sensible defaults for each toolkit.
22 -- **Composio branding on consent screens fits your product.** Users see Composio's app name during OAuth. You can still [white-label the Connect Link page](/docs/authentication/white-labeling-authentication#customizing-the-connect-link) with your logo and app title without needing your own OAuth app.
21 +You can still [white-label the Connect Link page](/docs/authentication/white-labeling-authentication#customizing-the-connect-link) with your logo and app title on a managed app.
22
24 -## When to use a custom auth config
23 +## What a managed app limits
24
26 -Bring your own credentials when any of these apply:
25 +- **Shared provider quota.** Provider quotas that apply per OAuth app are shared by every Composio customer on the managed app, so traffic you don't control counts against the limit your users depend on. Your own app gets its own quota. See [provider quota errors](/reference/rate-limits#provider-quota-errors).
26 +- **Composio's name on the consent screen.** Users see Composio's app name when they approve access, not yours.
27 +- **Composio's scope set.** You can [adjust scopes](/docs/authentication/controlling-scopes) on a managed config, but only within what Composio's app is set up to request. A scope outside that set needs your own app.
28 +- **Slower polling triggers.** Managed auth enforces a 2-minute minimum polling interval. Your own app can use shorter intervals where supported.
29
28 -- **You need your app name on OAuth consent screens.** Use your own OAuth app when your product's branding requirements call for it.
29 -- **You need custom scopes.** Composio's default scopes may not include everything you need (e.g., write access to a specific Google API).
30 -- **You're hitting rate limits.** Managed apps share quota across all Composio users. Your own app gets a dedicated quota.
31 -- **You need faster polling triggers.** Managed auth enforces a 2-minute minimum polling interval; your own app can use shorter polling intervals where supported.
32 -- **You're connecting to a custom instance.** Self-hosted or regional variants (e.g., a private Salesforce subdomain) need their own OAuth app.
33 -- **Enterprise customers require your branding end-to-end.**
30 +## When to move to your own app
31
35 -## Create a custom auth config
32 +Move before you scale. Switching later means existing users reconnect, so the cost grows with your user count. Also move when any of these apply:
33 +
34 +- **You need your app name on OAuth consent screens.** Your product or your enterprise customers require your branding end to end.
35 +- **You need custom scopes.** Composio's scopes may not include everything you need, for example write access to a specific Google API.
36 +- **You're hitting provider rate limits.** Your own app stops sharing quota with other Composio customers.
37 +- **You need faster polling triggers.**
38 +- **You're connecting to a custom instance.** Self-hosted or regional variants, such as a private Salesforce subdomain, need their own OAuth app.
39 +
40 +Some toolkits have no managed app at all. See [Toolkits without managed auth](#toolkits-without-managed-auth).
41
37 -To check whether Composio provides the OAuth app for a toolkit, see [Managed OAuth apps](/toolkits/managed-auth). You can still create a custom auth config for branding, scopes, rate limits, polling intervals, or custom instances.
42 +Already have users on a managed app? Follow [Move from a Composio-managed app to your own OAuth app](/docs/migration-guide/managed-to-own-app) to switch while existing connections keep working.
43 +
44 +## Create a custom auth config
45
39 -The steps below use the dashboard. To create auth configs in code instead, for example one per customer, see [Programmatic auth configs](/docs/authentication/programmatic-auth-configs).
46 +To check whether Composio provides the OAuth app for a toolkit, see [Managed OAuth apps](/toolkits/managed-auth). The steps below use the dashboard. To create auth configs in code instead, for example one per customer, see [Programmatic auth configs](/docs/authentication/programmatic-auth-configs).
47
48 <Steps>
49 <Step>
@@ -44,7 +51,7 @@ The steps below use the dashboard. To create auth configs in code instead, for e
51
52 In the [Composio dashboard](https://dashboard.composio.dev/~/project/auth-configs?utm_source=docs&utm_medium=content&utm_campaign=docs-custom-app-vs-managed-app):
53
47 -1. Click **Create Auth Config**
54 +1. Click **Create**
55 2. Select the toolkit
56 3. Choose the auth scheme (OAuth2, API Key, Bearer Token, etc.)
57 4. Follow the dashboard instructions for the required credential fields
@@ -65,7 +72,7 @@ Step-by-step OAuth guides: [Google](https://composio.dev/auth/googleapps) | [Git
72 <Step>
73 <StepTitle>Save and copy the auth config ID</StepTitle>
74
68 -After you enter the required credentials, click **Create** and copy the auth config ID (for example, `ac_1234abcd`).
75 +After you enter the required credentials, click **Create Auth Config** and copy the auth config ID (for example, `ac_1234abcd`).
76 </Step>
77
78 <Step>
@@ -165,4 +172,7 @@ Some OAuth toolkits do not have a Composio-managed OAuth app. Check [Managed OAu
172
173 ## Next
174
168 -<Card icon={<Code />} title="Programmatic auth configs" href="/docs/authentication/programmatic-auth-configs" description="Create auth configs in code and pass them to a session" />
175 +<Cards>
176 + <Card icon={<Code />} title="Programmatic auth configs" href="/docs/authentication/programmatic-auth-configs" description="Create auth configs in code and pass them to a session" />
177 + <Card icon={<RouteIcon />} title="Move to your own OAuth app" href="/docs/migration-guide/managed-to-own-app" description="Switch existing users from a Composio-managed app to your own" />
178 +</Cards>
docs/content/docs/authentication/white-labeling-authentication.mdx
+2 -5
@@ -241,11 +241,8 @@ Set `COMPOSIO_API_KEY` in your server environment. Persist `request.id` with the
241
242 ### Switching from Composio-managed to your own OAuth app
243
244 -Existing connected accounts are tied to the auth config they were created with. Switching to a custom auth config affects new connections for that toolkit; existing users keep using their current connected accounts until they re-authenticate or you import/migrate their credentials.
245 -
246 -- To use the custom config for new connections, pass `authConfigs` when creating or updating the session.
247 -- Existing connections continue refreshing with their original auth config.
248 -- To fully migrate an existing user, delete the old connected account and have them re-authenticate with the new auth config, or import their credentials into the new config where supported.
244 +Existing connected accounts stay on the auth config they were created with, and tokens issued to Composio's app can't move to yours, so existing users reconnect.
245 +Follow [Move from a Composio-managed app to your own OAuth app](/docs/migration-guide/managed-to-own-app) to run both configs side by side, reconnect users, and recreate their triggers.
246
247 ## Build an app-owned connection UI
248
docs/content/docs/migration-guide/index.mdx
+6
@@ -13,6 +13,12 @@ written: "December 2025"
13 [View No Auth to Instant migration guide →](/docs/migration-guide/no-auth-to-instant)
14 </Accordion>
15
16 + <Accordion title="Move from a Composio-managed app to your own OAuth app">
17 + Switch a toolkit to your own OAuth app. New users connect to your app, and existing users keep working on the managed app until they reconnect.
18 +
19 + [View managed app migration guide →](/docs/migration-guide/managed-to-own-app)
20 + </Accordion>
21 +
22 <Accordion title="Migrating from Direct Tools to Sessions">
23 Move from manual tool fetching and execution to the sessions paradigm. Your existing auth configs and connected accounts carry over.
24
docs/content/docs/migration-guide/managed-to-own-app.mdx new
+310
@@ -0,0 +1,310 @@
1 +---
2 +title: Move from a Composio-managed app to your own OAuth app
3 +description: Register your own OAuth app, route new connections to it, reconnect existing users, and recreate their triggers
4 +keywords: [migrate, managed auth, own oauth app, custom auth config, bring your own app, reconnect, white label, provider quota]
5 +---
6 +
7 +This guide is for apps that already have users connected through a [Composio-managed app](/toolkits/managed-auth) and want to switch a toolkit to their own OAuth app. To decide whether you need to, read [Managed vs custom auth](/docs/authentication/custom-app-vs-managed-app).
8 +
9 +You move one toolkit at a time. Each toolkit gets its own auth config, so Gmail can move while Slack stays on the managed app.
10 +
11 +## What carries over
12 +
13 +- **Your user IDs, sessions, and agent code.** Only the auth config a session uses for the toolkit changes.
14 +- **Existing connected accounts.** They keep working and refreshing on the managed auth config until you disable or delete them.
15 +- **Token custody.** Composio still stores and refreshes tokens for connections on your own app. See [OAuth app ownership and token custody](/docs/security/token-custody#oauth-app-ownership-and-token-custody).
16 +
17 +## What doesn't carry over
18 +
19 +Existing users must reconnect. A provider issues OAuth tokens to a specific client ID, so tokens granted to Composio's app only work with Composio's app. Your app can't refresh or reuse them.
20 +
21 +You also can't export managed tokens and import them under your new config. Connected-account API responses [redact credential fields](/docs/auth-configuration/connected-accounts#credential-masking), and reading account state isn't a supported token-export path. [Importing existing connections](/docs/authentication/importing-existing-connections) only covers credentials your application already holds.
22 +
23 +Trigger instances belong to a connected account, so each reconnected user needs new triggers too.
24 +
25 +## How the move works
26 +
27 +Run both configs side by side. New users and users who have reconnected use your app. Everyone else stays on the managed app until they reconnect.
28 +
29 +```mermaid
30 +flowchart LR
31 + N["New users"] --> O["Your OAuth app<br/>(custom auth config)"]
32 + R["Existing users who reconnected"] --> O
33 + E["Existing users who haven't reconnected"] --> M["Composio-managed app<br/>(managed auth config)"]
34 + E -.->|reconnect| R
35 +```
36 +
37 +## Migrating
38 +
39 +<Steps>
40 +<Step>
41 +<StepTitle>Register your OAuth app with the provider</StepTitle>
42 +
43 +Create an OAuth app in the provider's developer portal. Set its name, logo, support details, and the scopes your product needs. Step-by-step guides: [Google](https://composio.dev/auth/googleapps) | [GitHub](https://composio.dev/auth/github) | [Slack](https://composio.dev/auth/slack) | [HubSpot](https://composio.dev/auth/hubspot) | [All toolkits](https://composio.dev/auth)
44 +
45 +You add the redirect URI in the next step, once Composio shows it to you.
46 +
47 +<Callout type="warn" title="Start provider verification early">
48 +Some providers review apps before real users can authorize them. Google, for example, requires verification for sensitive and restricted scopes, and that review can take weeks. Submit your app before you plan to switch, and keep users on the managed app until the provider approves it.
49 +</Callout>
50 +</Step>
51 +
52 +<Step>
53 +<StepTitle>Create a custom auth config</StepTitle>
54 +
55 +In the [dashboard's auth configs](https://dashboard.composio.dev/~/project/auth-configs?utm_source=docs&utm_medium=content&utm_campaign=docs-managed-to-own-app), click **Create** and select the toolkit. Choose **OAuth2**, enable **Use your own developer credentials**, and enter your app's client ID, client secret, and scopes.
56 +
57 +Copy the **Redirect URI** from the form into your provider app's list of authorized redirect URIs. The two values must match exactly. See [Using your own OAuth apps](/docs/authentication/white-labeling-authentication#using-your-own-oauth-apps) for which callback URL to use.
58 +
59 +<Figure src="/images/own-oauth-app-auth-config-form.png" alt="The credentials section of the Gmail auth config form, with fields for client ID, client secret, redirect URI, and scopes" caption="Enter your app's credentials, copy the redirect URI to the provider, and choose scopes" size="sm" />
60 +
61 +Click **Create Auth Config** and copy the new `ac_...` ID. Also note the ID of the managed auth config your existing users connected through. The dashboard marks it as **Managed**.
62 +
63 +To create the config in code instead, see [Programmatic auth configs](/docs/authentication/programmatic-auth-configs#your-own-oauth2-credentials).
64 +</Step>
65 +
66 +<Step>
67 +<StepTitle>Send new connections to your app</StepTitle>
68 +
69 +A session uses a custom auth config only when you pass it in `auth_configs` (Python) or `authConfigs` (TypeScript), keyed by toolkit. The session then finds or creates the user's connection on that config. See [Precedence](/docs/configuring-sessions#precedence).
70 +
71 +That means a session pointed at your app asks an existing user to connect again. Make this change once the provider has approved your app. To keep existing users working, choose the config per user: your app for anyone with an active connection on it or no managed connection at all, and the managed config for everyone else.
72 +
73 +<Tabs groupId="language" items={['Python', 'TypeScript', 'API']} persist>
74 +<Tab value="Python">
75 +```python
76 +from composio import Composio
77 +
78 +composio = Composio()
79 +
80 +OWN_APP_CONFIG = "ac_your_own_gmail_config"
81 +MANAGED_CONFIG = "ac_your_managed_gmail_config"
82 +
83 +
84 +def has_active_connection(user_id: str, auth_config_id: str) -> bool:
85 + accounts = composio.connected_accounts.list(
86 + user_ids=[user_id],
87 + auth_config_ids=[auth_config_id],
88 + statuses=["ACTIVE"],
89 + )
90 + return len(accounts.items) > 0
91 +
92 +
93 +def gmail_auth_config_for(user_id: str) -> str:
94 + if has_active_connection(user_id, OWN_APP_CONFIG):
95 + return OWN_APP_CONFIG
96 + if has_active_connection(user_id, MANAGED_CONFIG):
97 + return MANAGED_CONFIG
98 + return OWN_APP_CONFIG
99 +
100 +
101 +session = composio.create(
102 + user_id="user_123",
103 + auth_configs={"gmail": gmail_auth_config_for("user_123")},
104 +)
105 +```
106 +</Tab>
107 +<Tab value="TypeScript">
108 +```typescript
109 +import { Composio } from '@composio/core';
110 +
111 +const composio = new Composio();
112 +
113 +const OWN_APP_CONFIG = 'ac_your_own_gmail_config';
114 +const MANAGED_CONFIG = 'ac_your_managed_gmail_config';
115 +
116 +async function hasActiveConnection(userId: string, authConfigId: string): Promise<boolean> {
117 + const accounts = await composio.connectedAccounts.list({
118 + userIds: [userId],
119 + authConfigIds: [authConfigId],
120 + statuses: ['ACTIVE'],
121 + });
122 + return accounts.items.length > 0;
123 +}
124 +
125 +async function gmailAuthConfigFor(userId: string): Promise<string> {
126 + if (await hasActiveConnection(userId, OWN_APP_CONFIG)) return OWN_APP_CONFIG;
127 + if (await hasActiveConnection(userId, MANAGED_CONFIG)) return MANAGED_CONFIG;
128 + return OWN_APP_CONFIG;
129 +}
130 +
131 +const session = await composio.create('user_123', {
132 + authConfigs: { gmail: await gmailAuthConfigFor('user_123') },
133 +});
134 +```
135 +</Tab>
136 +<Tab value="API">
137 +```bash
138 +OWN_APP_CONFIG="ac_your_own_gmail_config"
139 +MANAGED_CONFIG="ac_your_managed_gmail_config"
140 +
141 +# Count the user's active connections on each config
142 +ON_OWN_APP=$(curl -s "https://backend.composio.dev/api/v3.1/connected_accounts?user_ids=user_123&auth_config_ids=$OWN_APP_CONFIG&statuses=ACTIVE" \
143 + -H "x-api-key: $COMPOSIO_API_KEY" | jq '.items | length')
144 +ON_MANAGED=$(curl -s "https://backend.composio.dev/api/v3.1/connected_accounts?user_ids=user_123&auth_config_ids=$MANAGED_CONFIG&statuses=ACTIVE" \
145 + -H "x-api-key: $COMPOSIO_API_KEY" | jq '.items | length')
146 +
147 +GMAIL_CONFIG=$OWN_APP_CONFIG
148 +if [ "$ON_OWN_APP" -eq 0 ] && [ "$ON_MANAGED" -gt 0 ]; then
149 + GMAIL_CONFIG=$MANAGED_CONFIG
150 +fi
151 +
152 +curl -X POST https://backend.composio.dev/api/v3.1/tool_router/session \
153 + -H "x-api-key: $COMPOSIO_API_KEY" \
154 + -H "Content-Type: application/json" \
155 + -d "{\"user_id\": \"user_123\", \"auth_configs\": {\"gmail\": \"$GMAIL_CONFIG\"}}"
156 +```
157 +</Tab>
158 +</Tabs>
159 +
160 +Toolkits you leave out of `auth_configs` keep their current behavior. Store which config each user is on in your own database if you'd rather not look it up on every session.
161 +</Step>
162 +
163 +<Step>
164 +<StepTitle>Reconnect existing users</StepTitle>
165 +
166 +Ask each existing user to connect again, for example with an in-app banner or at their next sign-in. Generate a Connect Link on your new config:
167 +
168 +<Tabs groupId="language" items={['Python', 'TypeScript', 'API']} persist>
169 +<Tab value="Python">
170 +```python
171 +from composio import Composio
172 +
173 +composio = Composio()
174 +request = composio.connected_accounts.link(
175 + user_id="user_123",
176 + auth_config_id="ac_your_own_gmail_config",
177 + callback_url="https://your-app.com/connections/callback",
178 +)
179 +```
180 +</Tab>
181 +<Tab value="TypeScript">
182 +```typescript
183 +import { Composio } from '@composio/core';
184 +
185 +const composio = new Composio();
186 +const request = await composio.connectedAccounts.link(
187 + 'user_123',
188 + 'ac_your_own_gmail_config',
189 + { callbackUrl: 'https://your-app.com/connections/callback' },
190 +);
191 +```
192 +</Tab>
193 +<Tab value="API">
194 +```bash
195 +curl --request POST \
196 + --url https://backend.composio.dev/api/v3.1/connected_accounts/link \
197 + --header "x-api-key: $COMPOSIO_API_KEY" \
198 + --header "Content-Type: application/json" \
199 + --data '{
200 + "auth_config_id": "ac_your_own_gmail_config",
201 + "user_id": "user_123",
202 + "callback_url": "https://your-app.com/connections/callback"
203 + }' | jq '{connected_account_id, redirect_url}'
204 +```
205 +</Tab>
206 +</Tabs>
207 +
208 +Send the browser to the returned redirect URL. The user now sees your app's name on the provider's consent screen. Once the new connection is `ACTIVE`, the routing from the previous step sends that user's sessions to your app.
209 +
210 +Use the same user ID the managed connection has. A different user ID creates a connection that your sessions and triggers won't match to the existing user.
211 +</Step>
212 +
213 +<Step>
214 +<StepTitle>Recreate triggers on the new connection</StepTitle>
215 +
216 +Triggers stay attached to the managed connected account. List them, create the same trigger type and config on the new connected account, then disable the old instance:
217 +
218 +<Tabs groupId="language" items={['Python', 'TypeScript', 'API']} persist>
219 +<Tab value="Python">
220 +```python
221 +from composio import Composio
222 +
223 +composio = Composio()
224 +
225 +old_triggers = composio.triggers.list_active(
226 + connected_account_ids=["ca_old_managed_account"],
227 +)
228 +
229 +for trigger in old_triggers.items:
230 + composio.triggers.create(
231 + slug=trigger.trigger_name,
232 + connected_account_id="ca_new_own_app_account",
233 + trigger_config=trigger.trigger_config,
234 + )
235 + composio.triggers.disable(trigger_id=trigger.id)
236 +```
237 +</Tab>
238 +<Tab value="TypeScript">
239 +```typescript
240 +import { Composio } from '@composio/core';
241 +
242 +const composio = new Composio();
243 +
244 +const oldTriggers = await composio.triggers.listActive({
245 + connectedAccountIds: ['ca_old_managed_account'],
246 +});
247 +
248 +for (const trigger of oldTriggers.items) {
249 + await composio.triggers.create('user_123', trigger.triggerName, {
250 + connectedAccountId: 'ca_new_own_app_account',
251 + triggerConfig: trigger.triggerConfig,
252 + });
253 + await composio.triggers.disable(trigger.id);
254 +}
255 +```
256 +</Tab>
257 +<Tab value="API">
258 +```bash
259 +# List triggers on the managed connection
260 +curl -s "https://backend.composio.dev/api/v3.1/trigger_instances/active?connected_account_ids=ca_old_managed_account" \
261 + -H "x-api-key: $COMPOSIO_API_KEY" | jq '.items[] | {id, trigger_name, trigger_config}'
262 +
263 +# For each one, create the same trigger type on the new connection.
264 +# Use its trigger_name in the URL and copy its trigger_config into the body.
265 +curl -X POST https://backend.composio.dev/api/v3.1/trigger_instances/GMAIL_NEW_GMAIL_MESSAGE/upsert \
266 + -H "x-api-key: $COMPOSIO_API_KEY" \
267 + -H "Content-Type: application/json" \
268 + -d '{"user_id": "user_123", "connected_account_id": "ca_new_own_app_account", "trigger_config": {}}'
269 +
270 +# Then disable the old instance
271 +curl -X PATCH https://backend.composio.dev/api/v3.1/trigger_instances/manage/ti_old_trigger \
272 + -H "x-api-key: $COMPOSIO_API_KEY" \
273 + -H "Content-Type: application/json" \
274 + -d '{"status": "disable"}'
275 +```
276 +</Tab>
277 +</Tabs>
278 +
279 +Results are cursor-paginated. If the list returns a next cursor, fetch the next page as shown in [Listing active triggers](/docs/setting-up-triggers/managing-triggers#listing-active-triggers). Polling triggers on your own app can use shorter intervals than the managed minimum where the toolkit supports it.
280 +
281 +Disable the old trigger rather than deleting it until you've confirmed events arrive from the new one. Otherwise both instances fire for the same event while they overlap.
282 +</Step>
283 +
284 +<Step>
285 +<StepTitle>Retire the managed connections</StepTitle>
286 +
287 +After a user's new connection works, [disable](/docs/auth-configuration/connected-accounts#enable-and-disable-accounts) their managed connected account. Disabling an account also disables its triggers, and you can re-enable it if something goes wrong. Once you're confident, [delete the old triggers](/docs/setting-up-triggers/managing-triggers#deleting-triggers) and [delete the managed connected account](/docs/auth-configuration/connected-accounts#delete-accounts). Deletion is permanent.
288 +
289 +To revoke the upstream token as well, use [Revoke accounts](/docs/auth-configuration/connected-accounts#revoke-accounts) where the toolkit supports it.
290 +
291 +When no active connections remain on the managed config, every user is on your app. You can then pass your config in every session and drop the routing logic.
292 +</Step>
293 +</Steps>
294 +
295 +## Checklist
296 +
297 +1. Your OAuth app is registered, and the provider has approved it for the scopes you need.
298 +2. The provider's authorized redirect URI matches the one in your custom auth config.
299 +3. Sessions route each user to the right config, and new users land on your app.
300 +4. Existing users have a way to reconnect, under the same user ID.
301 +5. Triggers exist on each new connection, and the old ones are disabled.
302 +6. Managed connected accounts are disabled or deleted once their replacements work.
303 +7. A connected-account list filtered to the managed config shows no active accounts.
304 +
305 +## Next
306 +
307 +<Cards>
308 + <Card icon={<Key />} title="Managed vs custom auth" href="/docs/authentication/custom-app-vs-managed-app" description="What a managed app limits and when to move" />
309 + <Card icon={<Palette />} title="White-labeling authentication" href="/docs/authentication/white-labeling-authentication" description="Brand the Connect Link and configure callback URLs" />
310 +</Cards>
docs/content/docs/migration-guide/meta.json
+1
@@ -2,6 +2,7 @@
2 "title": "Migration guides",
3 "pages": [
4 "no-auth-to-instant",
5 + "managed-to-own-app",
6 "direct-to-sessions",
7 "mcp-servers-to-sessions",
8 "tool-router-beta",
docs/public/images/own-oauth-app-auth-config-form.png
Binary files /dev/null and b/docs/public/images/own-oauth-app-auth-config-form.png differ