New: AI-assisted search! Ask questions and follow-ups in full sentences for smarter, faster help. Try asking things like: “How do I change a builder's or borrower's email address?”

Setting Up Built Partner MCP in Snowflake Cowork

Prev Next

Purpose

Built Partner MCP lets authorized Built users access Built from compatible AI assistants. For Snowflake, your organization registers Built Partner MCP as an external MCP server in your Snowflake account, backed by an API integration that holds the OAuth configuration Built provides. Your organization then grants access to the roles that should see Built. Users connect to Built from the Cowork sources panel, or your team attaches the server to a Cortex Agent.

Each user signs in to Built individually. An administrator sets up the API integration once, but it doesn't hold any Built user's credentials. The first time a user asks for something that needs Built, Snowflake sends them to sign in with the same Built credentials they use in the Built application. Each user's Built identity, permissions, and access controls stay in place.

For an introduction to Partner MCP, see Built Partner MCP Overview


Target Users

Snowflake account administrators and data platform teams who want to make Built available to users through Snowflake Cowork or a Cortex Agent.


How It Works

Before You Begin

You need:

  • A Snowflake role with the CREATE INTEGRATION privilege on the account. By default, only ACCOUNTADMIN has it.

  • The CREATE EXTERNAL MCP SERVER privilege on the schema where the server object will live.

  • The Built Partner MCP server URL, provided by Built.

  • The OAuth configuration values, including the client secret, provided by Built.

  • Snowflake Cowork or Cortex Agents enabled in your account.

  • A Built account for each user who needs to access Built through Snowflake.

  • If your Snowflake account uses PrivateLink: the ability to run SYSTEM$ALLOWLIST_PRIVATELINK, so you can confirm your account's callback host with Built (see Step 4).

Important:

  • Don't set up the Built connection with a shared Built account or the credentials of the person creating the integration. The integration holds only the OAuth client that identifies Snowflake to Built. Each user signs in to Built with their own identity and permissions.

Step 1: Create the API Integration

Run the following as a role with the CREATE INTEGRATION privilege. Replace each placeholder with the value Built provided.

CREATE API INTEGRATION built_partner_mcp
  API_PROVIDER = external_mcp
  API_ALLOWED_PREFIXES = ('<MCP server URL provided by Built>')
  API_USER_AUTHENTICATION = (
    TYPE = OAUTH2
    OAUTH_CLIENT_ID = '<client ID provided by Built>'
    OAUTH_CLIENT_SECRET = '<client secret provided by Built>'
    OAUTH_AUTHORIZATION_ENDPOINT = '<authorization endpoint provided by Built>'
    OAUTH_TOKEN_ENDPOINT = '<token endpoint provided by Built>'
    OAUTH_CLIENT_AUTH_METHOD = CLIENT_SECRET_BASIC
    OAUTH_ALLOWED_SCOPES = ('openid', 'email', 'profile')
    OAUTH_REFRESH_TOKEN_VALIDITY = 86400
  )
  ENABLED = TRUE;

The values, for reference:

Setting

Value

Authentication type

OAUTH2 (a pre-registered client)

Client ID

Provided by Built

Client secret

Provided by Built

Authorization endpoint

Provided by Built

Token endpoint

Provided by Built

Client auth method

CLIENT_SECRET_BASIC (default) or CLIENT_SECRET_POST. Built accepts either.

Scopes

openid, email, profile

Refresh token validity

86400 seconds. Built sessions expire after one day regardless of this value, so a longer setting has no effect. Snowflake requires at least 3600.

Built provides the client secret to your IT admin team as a secure credential. Store and share it according to your organization's secrets-management policies. Don't include it in tickets, screenshots, documentation, chat messages, or other broadly accessible locations. Snowflake stores the value encrypted and doesn't display it again after the integration is created.

Note:

  • Use the exact URLs Built provides for your environment. The URL in API_ALLOWED_PREFIXES must cover the exact MCP server URL you use in Step 2.

  • Use TYPE = OAUTH2, not OAUTH_DYNAMIC_CLIENT. Built supports only the pre-registered client described here and doesn't support Dynamic Client Registration. An integration created with TYPE = OAUTH_DYNAMIC_CLIENT fails with Snowflake error 010754: OAuth dynamic client registration is not supported by the authorization server.

Step 2: Create the External MCP Server

In the database and schema where your organization keeps integration objects, run:

CREATE EXTERNAL MCP SERVER built_partner_mcp
  WITH DISPLAY_NAME = 'Built'
  URL = '<MCP server URL provided by Built>'
  API_INTEGRATION = built_partner_mcp;

The display name is what users see in Cowork. Your organization can choose a name that matches its internal conventions, such as Built or Built Construction Finance.

The Built MCP server supplies the list of tools available to the agent automatically. Nothing about the tool list is configured in Snowflake.

Step 3: Grant Access to Users

Users connect to Built through a Snowflake role that has USAGE on both objects. Grant them to each role that should see Built in Cowork or through an agent:

GRANT USAGE ON EXTERNAL MCP SERVER built_partner_mcp TO ROLE <role_name>;
GRANT USAGE ON INTEGRATION built_partner_mcp TO ROLE <role_name>;

Built recommends starting with a small pilot role before granting access broadly.

Granting these privileges doesn't give users a shared connection to Built. Each user's Built access is set up separately when that user connects.

Skip this step if your Snowflake account doesn't use PrivateLink.

When a user signs in, Built sends the user back to Snowflake at a callback URL. For standard accounts, this is a fixed Snowflake address that Built already accepts. PrivateLink accounts also use an account-specific callback host. Built accepts any host under privatelink.snowflakecomputing.com at the path Snowflake uses, so in most cases nothing more is required.

To confirm, run:

SELECT SYSTEM$ALLOWLIST_PRIVATELINK();

Find the entry beginning app.<region>.privatelink.snowflakecomputing.com (or app-<deployment>.<region>.privatelink.snowflakecomputing.com). Share that host with your Built contact before users start connecting. If Snowflake reports a callback host outside privatelink.snowflakecomputing.com, Built needs to know before rollout, because sign-in attempts from an unrecognized callback are rejected.

Step 5: Test the Connection

Before granting access broadly:

  1. Sign in to Snowflake with a role that has the grants from Step 3.

  2. Open Cowork and open the sources or Connectors panel.

  3. Find the Built connector and select Connect.

  4. Snowflake opens a Built sign-in page. Enter your work email, then sign in with your own Built credentials.

  5. Complete any authorization or consent prompt from Built.

  6. Snowflake returns you to Cowork, and the connector shows as Connected.

  7. Ask a question that requires access to Built, such as a question about a project or loan you can see in Built.

  8. Confirm Cowork uses a Built tool and returns an appropriate result.

Access reflects the permissions of the Built user who signed in. For example, if a user can't access a project in Built, connecting through Snowflake doesn't give them access to it.

Testing from SQL: Administrators can also run the sign-in flow without the Cowork interface, which is useful when testing an agent:

-- Returns the Built authorization URL. Open it in a browser and sign in.
SELECT SYSTEM$START_USER_OAUTH_FLOW('BUILT_PARTNER_MCP');

-- After sign-in, Built redirects to a Snowflake URL. Pass its query string here.
SELECT SYSTEM$FINISH_OAUTH_FLOW('<query string from the redirect URL>');

Step 6: Attach the Server to a Cortex Agent (Optional)

If your organization makes Built available through a Cortex Agent instead of, or in addition to, Cowork, add the server to the agent's specification:

ALTER AGENT <agent_name>
  MODIFY LIVE VERSION SET SPECIFICATION $$
    <existing specification>
    mcp_servers:
      - server_spec:
          name: "<database>.<schema>.BUILT_PARTNER_MCP"
  $$;

Give the agent instructions describing when to use Built. For example, tell it to use Built tools when a user asks about projects, loans, draws, inspections, documents, or other information in your organization's Built environment.

Agent users sign in to Built the same way as Cowork users. Each user is prompted to sign in the first time the agent needs Built on their behalf.

Step 7: What Users Experience

  1. The user opens Snowflake Cowork.

  2. The user opens the sources panel and finds the Built connector your organization provides.

  3. The user selects Connect.

  4. The user goes through Built's sign-in and signs in with their Built credentials.

  5. The user approves access if prompted.

  6. Snowflake returns the user to Cowork and marks the connector as connected. The user can now ask questions or request actions involving Built.

Sign-in is per Built user. A user's access through Snowflake follows the same Built account status, organization membership, roles, and permissions that apply when they use Built directly.

Built sessions last one day. After that, the connector shows as disconnected, and the user reconnects by signing in again.

Step 8: Validate the Deployment

Before completing rollout, test with at least two Built users who have different permissions. Confirm that:

  • Each user is prompted separately to sign in to Built.

  • Each user signs in with their own Built account.

  • Users can access only the Built information they're authorized to access.

  • Changing or removing a user's permissions in Built affects their access through Snowflake as expected.

  • No administrator credentials are shared across users.

Troubleshooting

Symptom

What to check

010754: OAuth dynamic client registration is not supported when creating the integration or connecting

The integration was created with TYPE = OAUTH_DYNAMIC_CLIENT. Recreate it with TYPE = OAUTH2 as in Step 1.

Snowflake rejects the CREATE API INTEGRATION statement over OAUTH_REFRESH_TOKEN_VALIDITY

The value is below Snowflake's minimum of 3600. Use 86400.

The Built sign-in page never appears, or Built reports an invalid client

OAUTH_CLIENT_ID doesn't exactly match the value Built provided, or the authorization endpoint URL doesn't match the value Built provided.

Built reports invalid_request and the user isn't returned to Snowflake

Built didn't recognize the callback URL. For PrivateLink accounts, complete Step 4 and share your callback host with Built.

Sign-in completes, but the connection fails with an authentication error from Built

The client secret is wrong, or Built has rotated it. Get the current secret from Built and update the integration with ALTER API INTEGRATION built_partner_mcp SET API_USER_AUTHENTICATION = (...), supplying the full authentication block again.

Users can't see the Built connector in Cowork

Their active role doesn't have USAGE on the external MCP server or the API integration (Step 3), or the integration has ENABLED = FALSE.

Sign-in succeeds, but Built tools return an access error

The user has an active Built account but isn't enabled for MCP access, or doesn't have access to the relevant Built information. Contact Built.

A connection that worked yesterday now fails

The one-day Built session has expired. The user reconnects from the Cowork sources panel.

If the connector can't connect to Built, also check that:

  • The MCP server URL in Step 2 exactly matches the value provided by Built, and API_ALLOWED_PREFIXES in Step 1 covers it.

  • The authorization and token endpoint URLs match the values Built provided.

  • The user has an active Built account and can sign in to Built directly.

Capabilities and Limitations

  • Tools only: Snowflake's external MCP support covers MCP tools. MCP resources and prompts don't appear in Snowflake, so Built functionality available only through those channels isn't visible from Cowork.

  • Daily sign-in: Built sessions expire after one day. Users reconnect from the Cowork sources panel.

  • One integration per Built environment: If Built provides access to more than one environment, each needs its own API integration and external MCP server.

Note:

  • Snowflake provides the agent experience, while Built remains in control of access to Built. The administrator sets up the integration once but never signs in to Built on behalf of other users. The client secret identifies your Snowflake account's connector to Built and doesn't give access to any Built data on its own. Each user sets up their own Built connection.


Best Practices

  • Start with a small pilot role before granting access broadly.

  • Keep the client secret in your organization's secrets-management tools, never in tickets, chats, or screenshots.

  • PrivateLink accounts: confirm your callback host with Built before users start connecting.

Footer Example