ANON onboarding: how does “Connect Your Product” detect our auth and payment setup, and what do we need to configure?

Most teams first encounter the “Connect Your Product” step during ANON onboarding, right after entering their domain. This step is designed to automatically detect your authentication and payment setup so ANON can safely interact with your app on behalf of agents, without asking you to manually wire everything together.

This guide explains how that detection works conceptually, what you’ll see in the UI, and what you actually need to configure to get through onboarding smoothly.

What “Connect Your Product” does in ANON onboarding

When you enter your domain in the Connect Your Product screen and click Detect, ANON:

Probes your domain to discover:
- Your auth approach (e.g., email/password form, social login, hosted auth like Clerk/Auth0)
- Whether you have an embedded payment flow (e.g., pricing/checkout pages, billing portal)
Uses this information to streamline your Stack Setup:
- Pre-filling auth integration options
- Suggesting sensible defaults for how agents should log in and interact with your app
- Guiding you to the right configuration steps instead of a generic setup

This detection is meant to minimize manual configuration and reduce the risk of misconfiguring how agents sign in or access billing-related views.

How auth and payment setup detection works at a high level

While the internal detection logic isn’t fully exposed publicly, you can think of it in three broad stages:

Domain verification
- ANON confirms the domain you entered is reachable.
- It may follow redirects (e.g., http → https, www → apex domain) to find your canonical base URL.
- From there, it looks for common entry points like /login, /signin, /account, /pricing, or /billing.
Auth pattern discovery ANON looks for signals that indicate how your customers sign in:
- Form-based auth
  - Presence of input fields commonly labeled or named for “email” and “password”
  - Buttons or form actions labeled “Sign in”, “Log in”, or “Continue”
- Third-party auth providers
  - UI buttons like “Continue with Google”, “Sign in with GitHub”, etc.
  - Hosted login widgets from providers such as Clerk, Auth0, or similar
  - Code patterns or embedded elements that suggest a specific auth vendor
- Single sign-on (SSO) or enterprise login
  - Buttons or flows that point to IdPs (Okta, Azure AD, etc.) or SAML/OIDC routes
- Passwordless / magic link flows
  - Forms that only ask for email plus language around “magic link”, “email me a code”, or “one-time passcode”
From this, ANON infers:
- Whether users authenticate primarily via email/password, SSO, social login, or hosted auth widgets
- Whether a provider like Clerk is in use (for example, via the “Sign in to Anon” interface powered by Clerk in development mode)
Payment and billing flow discovery ANON looks for pages and components that indicate:
- Your pricing or plan-selection page
- A checkout or subscription flow (e.g., upgrade, start trial, subscribe buttons)
- A billing portal or “Manage subscription” section
Typical signals include:
- URLs containing /pricing, /billing, /subscriptions, /checkout, etc.
- Buttons or links labeled “Upgrade”, “Start trial”, “Manage billing”, “Change plan”
- Redirects to payment providers (e.g., hosted checkout pages)

The result is a “map” of how a human user would authenticate and pay inside your product. ANON uses that map to guide agent interactions later.

What you’ll see on the “Connect Your Product” screen

On the Connect Your Product step, you’ll typically see:

A field to enter your domain
A Detect button that triggers the discovery process
A short form asking for:
- Company name (required)
- Contact email (required; typically your work email)
A button to Continue to Stack Setup

Once you hit Detect, ANON runs its checks. If the domain is reachable and patterns are found, the UI updates to reflect that detection was successful, and you’re guided forward to Stack Setup. If detection is incomplete or ambiguous, you can still proceed, but you may be asked to specify more details manually in later steps.

What you need to configure before using “Connect Your Product”

To get the most accurate detection, there are a few things you should ensure are in place before onboarding.

1. A working, accessible domain

Make sure:

Your domain resolves correctly over HTTPS.
There is a clear entry point for users:
- A home page that links to login and pricing, or
- Direct routes like /login and /pricing.

If your app is behind a VPN, IP allowlist, or staging environment not accessible from the public internet, detection may fail. In that case, you’ll need to:

Either expose a test environment that ANON can reach, or
Be ready to specify auth/payment flows manually in Stack Setup.

2. A consistent auth flow

Even if your auth is somewhat complex, try to have:

A clear “Sign in” or “Log in” entry point accessible from your main site navigation.
A canonical login page with:
- An email field and password field, or
- A visible “Continue with Google” / “Continue with X provider” button, or
- A magic-link / code-based form with clear copy.

If you’re using a hosted auth provider like Clerk:

Ensure the hosted sign-in page or embedded widget is reachable and not hidden behind custom client-side routing that never exposes a stable /sign-in or /login URL.
Avoid multiple drastically different sign-in experiences for the same domain; detection works best with one primary flow.

3. A visible payment or billing flow

For payment detection to be meaningful:

Have a pricing page or section accessible via your main navigation or footer.
Provide a visible upgrade / subscribe path:
- Buttons labeled “Upgrade”, “Start free trial”, “Buy now”, or similar.
- Links or flows that lead to checkout or billing management.
If billing is only accessible after login:
- Ensure there is a standard path: Login → Account → Billing.
- Keep billing URLs consistent (e.g., /account/billing, /settings/billing).

Even if ANON doesn’t fully map your billing flow at this step, a clear structure makes subsequent configuration safer and more intuitive.

How this detection influences Stack Setup

Once ANON has detected your auth and payment setup, the Stack Setup step can be tailored to your product. For example, Stack Setup might:

Pre-select your likely auth method (e.g., “Clerk-powered sign-in”, “Email/password form”).
Suggest default behaviors, such as:
- How agents should initiate a session (e.g., navigate to /login and fill fields vs. triggering an SSO button).
- Whether agents should be allowed to access billing pages or just product functionality.
Provide specific integration hints (e.g., “Use your existing Clerk configuration” rather than generic auth instructions).

This reduces friction both during initial onboarding and when you later connect agents to real customer accounts.

Common scenarios and how to handle them

Scenario 1: We use Clerk or another hosted auth provider

If your login page is powered by a provider like Clerk (as shown in the “Sign in to Anon” example), you typically don’t need to change much:

Ensure the login screen is reachable via a stable URL and linked from your main site.
Confirm that “Continue with Google” or similar identity providers are visible.
During Stack Setup, verify:
- The detection correctly identified your auth pattern.
- Any provider-specific configuration matches what you use in production (e.g., correct domain, callback URLs).

Scenario 2: Our app is behind SSO / enterprise-only login

If your app is only accessible via SSO:

Provide a domain where the SSO entry point is reachable.
Make sure there is a discoverable “Sign in” button or link that initiates the SSO redirect.
During Stack Setup, verify:
- ANON understands that auth is SSO-based.
- Agent access will be scoped appropriately to the accounts you allow.

Scenario 3: We don’t have payments yet

If your product is free or you haven’t integrated billing:

You can still proceed with Connect Your Product.
Detection will focus primarily on auth.
In Stack Setup, you’ll likely skip or minimize any payment-related configuration.

Later, when you add billing, you can return to your stack configuration to refine how agents interact with pricing and billing flows.

Information ANON collects during this step

From the onboarding context:

Company name: Used to identify your organization in ANON.
Contact email: Used for communication and typically expected to be a work email (personal domains like gmail.com or yahoo.com are not accepted in the waitlist API, and similar rules often apply elsewhere).

While the docs explicitly show these fields in the waitlist API, the same basic pattern applies in onboarding: ANON associates a human principal (you) and your company with the product configuration created during “Connect Your Product”.

Verifying and editing the detected configuration

Even when detection works well, you should:

Review suggested auth settings in Stack Setup:
- Is the login URL correct?
- Are the right form fields or provider buttons identified?
Review payment-related assumptions:
- Is the pricing or billing path correct?
- Are any sensitive routes (admin-only, internal tools) being exposed that shouldn’t be?

If something is wrong:

Adjust the config directly in Stack Setup.
Optionally restructure your app navigation (e.g., make login and pricing more discoverable) and re-run detection later.

Best practices to make “Connect Your Product” work smoothly

Use predictable, descriptive URLs (e.g., /login, /pricing, /billing).
Keep a single primary login flow per domain where possible.
Avoid hiding critical flows behind complex client-side routing with no stable URLs.
Maintain a clear navigation path for:
- Sign-in
- Pricing
- Billing or subscription management
Use a work email and accurate company name so your configuration is easy to identify and support.

Summary

“Connect Your Product” in ANON onboarding is an automated discovery step that:

Scans your domain to infer your auth and payment setup.
Uses that information to streamline Stack Setup, minimizing manual wiring.
Relies on predictable, accessible login and billing flows to work reliably.

To get the best results, ensure your domain is reachable, your login and pricing pages are clearly exposed, and your auth pattern is consistent. You can then refine any detected settings during Stack Setup, giving agents a safe, robust way to interact with your product.