Build with AI

Use AI agents to create, configure, and verify GrowSurf referral and affiliate programs.

MCP

GrowSurf's MCP server lets an AI agent work directly with your GrowSurf programs. It can create a referral or affiliate program, tune the design, inspect email/options defaults, configure rewards, wire webhooks, manage participants, and read analytics.

What an agent can do

Create entire referral/affiliate programs with a one-shot prompt:

Create a GrowSurf referral program for Acme, keep rewards disabled until I approve them, then summarize the Design, Emails, Options, Installation, and Rewards settings.

New to GrowSurf? OAuth connector clients (ChatGPT, Claude, and other sign-in flows) connect to an existing team, so sign up first if you do not have a GrowSurf account. An agent can also sign up for you: connect it to the onboarding endpoint https://mcp.growsurf.com/onboard with no credentials (or use the local server or API-key setup) and have it call growsurf_create_account. The returned API key is locked until the team owner's email address is verified. After the owner clicks the verification link, the agent continues with the same API key.

Connect the MCP server

You need one of these:

A GrowSurf account (sign up here or programmatically via /POST Create Account).
A GrowSurf API key for local setup or remote clients that do not support GrowSurf sign-in.
Optional: a default campaign id. You can skip this if your agent will create a new campaign first, then pass the returned id as campaignId.

Add GrowSurf as a developer-mode app (custom connector) in ChatGPT on the web.

Open Settings > Connectors > Advanced and turn on Developer mode. Enterprise workspaces need an admin to allow it.
In the Connectors tab, select Create, name the app GrowSurf, and set authentication to OAuth.
Use this MCP server URL:
```
https://mcp.growsurf.com/mcp
```
Optional: add the GrowSurf logo.
Finish the OAuth flow, then start a new chat, choose Developer mode from the + menu, and enable GrowSurf.

ChatGPT registers its own OAuth client automatically, so you do not paste an API key.

Add GrowSurf as a remote custom connector in Claude on the web.

Open Settings > Connectors. On Team or Enterprise, an organization owner must first add the connector under Organization settings > Connectors.
Select Add custom connector and name it GrowSurf. Organization owners choose Add > Custom > Web.
Enter this remote MCP server URL:
```
https://mcp.growsurf.com
```
Select Add, then Connect, and sign in to GrowSurf to approve the requested access.

Claude remote connectors are tied to your Claude account and also work in Claude Desktop.

Open Settings > Connectors for the same Claude account you use in Claude Desktop.
Select Add custom connector and name it GrowSurf. On Team or Enterprise, an organization owner must add it first.
Enter this remote MCP server URL:
```
https://mcp.growsurf.com
```
Select Connect, sign in to GrowSurf, approve access, then enable GrowSurf in Claude Desktop.

Recommended: connect Claude Code to GrowSurf's hosted MCP endpoint:

claude mcp add --transport http --scope user growsurf https://mcp.growsurf.com

On first use, Claude Code opens GrowSurf sign-in and consent. You can also start that flow directly:

claude mcp login growsurf

If you prefer local stdio, install the local server directly into Claude Code:

claude mcp add growsurf \
  -e GROWSURF_API_KEY=YOUR_API_KEY \
  -- npx -y @growsurfteam/growsurf-mcp

For a single existing campaign in local stdio, add:

-e GROWSURF_CAMPAIGN_ID=YOUR_CAMPAIGN_ID

Manual API-key fallback for the hosted endpoint:

claude mcp add --transport http growsurf https://mcp.growsurf.com/mcp \
  --header "Authorization: Bearer YOUR_API_KEY"

For a single existing campaign on the manual hosted path, add:

--header "x-growsurf-campaign-id: YOUR_CAMPAIGN_ID"

Add GrowSurf as a remote MCP server in VS Code, then use it from Copilot's agent mode.

Run this in your terminal, or open the Command Palette and run MCP: Add Server > HTTP:

code --add-mcp '{"name":"growsurf","type":"http","url":"https://mcp.growsurf.com"}'

Open Copilot Chat, switch to Agent mode, start GrowSurf, then sign in and approve access when VS Code prompts you.

Open Cursor Settings > Tools & Integrations, select New MCP Server, and add a server named growsurf.

Recommended: add GrowSurf's hosted MCP endpoint to mcp.json:

{
  "mcpServers": {
    "growsurf": {
      "url": "https://mcp.growsurf.com"
    }
  }
}

For API-key auth instead of OAuth, use the manual hosted path:

{
  "mcpServers": {
    "growsurf": {
      "url": "https://mcp.growsurf.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

If you prefer local stdio, add this to mcp.json:

{
  "mcpServers": {
    "growsurf": {
      "command": "npx",
      "args": ["-y", "@growsurfteam/growsurf-mcp"],
      "env": {
        "GROWSURF_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

Sign-in window didn't open? Some Cursor versions never open the GrowSurf sign-in window (a bug in Cursor, not your setup). Replace the growsurf entry with this configuration and reconnect. It needs Node.js installed, and opens sign-in in your browser on the first connection:

{
  "mcpServers": {
    "growsurf": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.growsurf.com"]
    }
  }
}

Recommended: connect Codex to GrowSurf's hosted MCP endpoint:

codex mcp add growsurf --url https://mcp.growsurf.com

Start GrowSurf sign-in and consent:

codex mcp login growsurf

Or create or edit ~/.codex/config.toml:

[mcp_servers.growsurf]
url = "https://mcp.growsurf.com"

For API-key auth instead of OAuth, point Codex at the manual hosted path and read the API key from an environment variable:

[mcp_servers.growsurf]
url = "https://mcp.growsurf.com/mcp"
bearer_token_env_var = "GROWSURF_API_KEY"

If you prefer local stdio, create or edit ~/.codex/config.toml:

[mcp_servers.growsurf]
command = "npx"
args = ["-y", "@growsurfteam/growsurf-mcp"]

[mcp_servers.growsurf.env]
GROWSURF_API_KEY = "YOUR_API_KEY"

Or configure it from the CLI:

codex mcp add growsurf \
  --env GROWSURF_API_KEY=YOUR_API_KEY \
  -- npx -y @growsurfteam/growsurf-mcp

Connect GrowSurf to Gemini CLI over HTTP:

gemini mcp add --transport http growsurf https://mcp.growsurf.com

Open Gemini CLI, run /mcp to check the connection, then finish signing in and approve access in your browser.

Add GrowSurf as a remote MCP server in Windsurf's Cascade.

Open Windsurf Settings > Cascade > Manage MCP servers, then add a custom server.
Add a remote server named GrowSurf with this URL:
```
https://mcp.growsurf.com
```
Refresh the server list, then sign in to GrowSurf and approve access.

Add GrowSurf as a remote MCP server in the Cline extension.

In Cline, open the MCP Servers panel and choose Remote Servers.
Add a server named GrowSurf with this URL:
```
https://mcp.growsurf.com
```
Connect, then sign in to GrowSurf and approve access.

Open Antigravity, click the … menu, select MCP Store, then open Manage MCP Servers > View raw config.

Recommended: add GrowSurf's hosted MCP endpoint to mcp_config.json. Antigravity uses serverUrl for remote MCP servers:

{
  "mcpServers": {
    "growsurf": {
      "serverUrl": "https://mcp.growsurf.com"
    }
  }
}

For API-key auth instead of OAuth, use the manual hosted path:

{
  "mcpServers": {
    "growsurf": {
      "serverUrl": "https://mcp.growsurf.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

If you prefer local stdio, add this to mcp_config.json:

{
  "mcpServers": {
    "growsurf": {
      "command": "npx",
      "args": ["-y", "@growsurfteam/growsurf-mcp"],
      "env": {
        "GROWSURF_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

For any other client that supports remote Streamable HTTP MCP servers with OAuth:

Add a remote Streamable HTTP MCP server and name it GrowSurf.
Use this OAuth-capable server URL:
```
https://mcp.growsurf.com
```
Start the connection, then sign in to GrowSurf and approve access.

If your client asks for a URL and custom headers instead of GrowSurf sign-in, use https://mcp.growsurf.com/mcp with header Authorization: Bearer YOUR_API_KEY.

Hosted Streamable HTTP endpoint

Use hosted OAuth when your MCP client supports remote Streamable HTTP with OAuth:

URL: https://mcp.growsurf.com
Auth: GrowSurf sign-in and consent.
API keys: not required for OAuth clients.

Use this option if your MCP client asks for a URL and custom headers instead of opening GrowSurf sign-in:

URL: https://mcp.growsurf.com/mcp
Required header for API-calling tools: Authorization: Bearer YOUR_API_KEY
Optional header for a default campaign: x-growsurf-campaign-id: YOUR_CAMPAIGN_ID

The local server and manual fallback can use the account-bootstrap tool without an API key. OAuth clients use the GrowSurf team you select and approve. Campaign-scoped tools need either a campaignId argument or a default campaign header/environment value.

Hosted OAuth connector

GrowSurf's hosted MCP endpoint supports OAuth for ChatGPT, Claude.ai, Claude Desktop, Claude Code, GitHub Copilot, Cursor, Codex, Gemini CLI, Windsurf, Cline, Antigravity, and other compatible remote MCP clients. Browser-only clients must support custom remote MCP/OAuth connectors; if yours does not, use a supported coding agent or the local stdio setup.

What access you approve

When you sign in through the hosted connector, GrowSurf asks you to approve access before the agent can do anything. The agent can then, on your behalf:

Read and update the selected team.
Read, create, and update programs; create, update, or delete their reward configuration and webhooks.
Read, add, update, and remove participants.
Record or refund sales and approve commissions or rewards.
Read analytics.

The hosted MCP server asks only for scopes used by its current tools. It does not request permission to rotate API keys, delete programs, read detailed reward, commission, or payout records, delete issued rewards, or fulfill rewards. API-key rotation is not an MCP action. Rotate a key from GrowSurf Settings or through a direct REST/SDK client whose API key has the api_key:rotate scope.

MCP Team tools stay on the team selected during approval.

You can review or revoke a connected client at any time from your GrowSurf account settings.

Example prompts

After you have the MCP installed, view these example prompts for quickly creating a GrowSurf program.

Referral programs

Ask your agent to use the GrowSurf MCP tools:

Use GrowSurf to create a referral program for Acme. Review the default Design, Emails, Options, Installation, and Rewards. Keep rewards safe until I approve them. Return the campaign editor URL and summarize the settings.

The agent should use this order:

growsurf_create_campaign with type: "REFERRAL".
growsurf_get_campaign, growsurf_list_campaign_rewards, growsurf_get_campaign_design, growsurf_get_campaign_emails, growsurf_get_campaign_options, and growsurf_get_campaign_installation.
Patch only requested changes with the growsurf_update_campaign_* tools.
Fetch the updated campaign, Design, Emails, Options, Installation, and Rewards before reporting back.

Affiliate programs

Affiliate programs can create payable obligations, so have the agent confirm payout and tax settings before launch:

Create an affiliate program for Acme in USD. Review commission defaults, payout threshold, tax collection, affiliate portal design, and emails. Do not publish until I approve the money settings.

The agent should inspect:

growsurf_list_campaign_rewards for commission/reward config.
growsurf_get_campaign_options for approval, payout, and tax settings.
growsurf_get_campaign_design for affiliate portal sections such as commissions, payouts, affiliate summary, and participant settings.
growsurf_get_campaign_design, growsurf_get_campaign_emails, and growsurf_get_campaign_options for configuration review.

Agent Skills

GrowSurf also ships an Agent Skill recipe layer with the MCP package. If your agent supports skills, install or copy the growsurf-agent-toolkit skill from the MCP package. It gives the agent a stricter workflow for:

Creating referral programs.
Creating affiliate programs.
Embedding the widget.
Adjusting rewards.
Wiring webhooks.
Reading analytics.

MCP prompts are also bundled in the server, so compatible MCP clients can discover the same recipes without a separate skill install.

Resources

Last updated 4 days ago

Was this helpful?