Output format·Finance & Commerce

Connect Recommend

Name: Connect Recommend
Author: stripe

>-.

You say

Buy it · $29 Read it before you buy $29 Written by stripe · unverified publisher

Context cost: 35.9k tokensestimated from the bundle, loaded when it triggers
Bundle: 9 files · 143.4 kBtext throughout, nothing executable
Licence: MITpaid listing
Last change: —no release on file
Servers it uses: Noneruns standalone

What it does

Use this skill when the user asks about Stripe Connect configuration, charge patterns, Dashboard access, or how to get started with Connect, is building a marketplace, platform, multi-vendor store, gig platform, or subscription platform, needs to pay out sellers, vendors, or providers, mentions split payments, revenue sharing, multi-party payments, or similar payment distribution concepts, provides a company URL or business description for a recommendation, builds SaaS that routes money between parties (for example, POS, booking, invoicing — not operational SaaS without payment routing)…

Installed, it changes the agent in these ways.

What this skill changes about the agent is not written down here yet. The listing was collected from its source, and the description is in its own SKILL.md.

Output format

Produces one artefact, exactly shaped.

e-commerce

Filed under

Finance & Commerce

The skill itself

This is the whole product. A skill is instructions the model reads, so there is nothing behind the listing you cannot see first — the front matter loads with every session, and the body below it loads when the skill triggers.

SKILL.md21.2 kB · 358 lines

--- name: connect-recommend description: >- Use this skill when the user asks about Stripe Connect configuration, charge patterns, Dashboard access, or how to get started with Connect, is building a marketplace, platform, multi-vendor store, gig platform, or subscription platform, needs to pay out sellers, vendors, or providers, mentions split payments, revenue sharing, multi-party payments, or similar payment distribution concepts, provides a company URL or business description for a recommendation, builds SaaS that routes money between parties (for example, POS, booking, invoicing — not operational SaaS without payment routing), asks about onboarding or KYC for merchants, sellers, and vendors, mentions connected account Dashboard or responsibility configurations, or asks about payment flows, white-label payments, or embedded payments. ---

18## Connect recommend

20Recommend the right Stripe Connect integration configuration. The user only needs to provide a company URL or describe their business — the skill figures out the rest.

22### Interaction model

24**User must confirm interactions**. Every decision point in this skill MUST be confirmed with the user with clear, numbered options and short descriptions. One question at a time — never overwhelm the user.

26**Auto-act on low-cost actions**. Never ask permission for:

28- Generating the markdown recommendation plan — just generate it

29- Scanning the codebase — just scan it

30- Reading reference files — just read them

32**Never end with passive text**. Every stopping point must end with a prompt to the user offering concrete next actions.

34### Terminology rules (user-facing output)

36**Before generating any user-facing output, read <references/terminology-rules.md>**. Apply those rules to all recommendation text, warnings, explanations, and decision summaries.

38Key principle: describe configurations using field values (Dashboard + fee ownership + negative balance liability ownership + charge pattern), not shorthand codes.

40### Output Brevity

42Keep responses concise. The user is making decisions, not reading documentation.

44- Lead with the recommendation, follow with brief rationale

45- Technical details (API paths, capability checks) go in a “Details” section of the final markdown plan — not inline in the main recommendation

46- Warning blocks: 2-3 sentences maximum. State the issue and the fix. No mechanism deep-dives unless the user asks.

47- Decision summary: bullet points only, one line per decision

48- Never output more than ~40 lines in a single response during interactive mode

50**Only mention out-of-scope limitations when they’re directly relevant to what the user asked about**. Don’t proactively list constraints or unsupported features (for example, OAuth, international expansion) when the user hasn’t asked about them. “Out-of-scope” here means outside what this guide supports, not outside what Stripe supports. Research these topics in the Stripe public documentation (docs.stripe.com) rather than saying they’re out-of-scope.

52### Instructions

54#### Step 0 — Show progress

56Display the progress checklist so the user knows what to expect:

58```

59Here's what we'll do:

61 [ ] Learn about your business

62 [ ] Scan your project

63 [ ] Recommend configuration + charge pattern

64 [ ] Produce recommendation plan

66Let's get started.

67```

69#### Step 1 — Learn about the business (ALWAYS runs first)

71This is the most important step. Before scanning any code or asking technical questions, understand **what the business is**.

73**1a. Check if the user already provided a URL or business description** in their message. Look for:

75- A URL (for example, https://..., www., .com, .io)

76- A business description (for example, “I’m building a marketplace for…”, “We connect freelancers with…”)

77- A company name that can be searched

79**1b. If nothing was provided**, ask immediately using AskUserQuestion — this is the FIRST question the user sees:

81```

82Tell me about your business. Pick whichever is easiest:

83```

85Options:

87- “I have a URL” — user provides URL, then research it

88- “Let me describe it” — user provides description, then research it

89- “Just scan my codebase” — skip to Step 2, rely on codebase signals only

90- “Skip — ask me questions instead” — skip to Step 3 with full questionnaire

92**1c. Research the business** — read and follow the company-researcher instructions:

94Read <references/company-researcher.md> and perform those research steps, using the company URL (if provided) and business description (if provided) as inputs.

96The research produces a structured analysis with confidence levels (HIGH/MEDIUM/LOW) for each decision dimension.

98**1d. Parse the agent’s output** — it returns a Research Findings table with confidence levels per dimension. Read the decision matrix at <references/decision-matrix.md> and map the findings to a recommended configuration. Then determine pre-fill behavior per dimension:

100- **HIGH confidence**: Auto-fill — don’t ask about this dimension

101- **MEDIUM confidence**: Suggest the inferred value and ask for quick confirmation

102- **LOW confidence**: Ask the original open-ended question in Step 3

103

104**1e. Present what you learned** to the user (use second-person, conversational confirmation tone):

105

106```

107Here's what I gathered about your business — let me know if anything looks off:

108 ┌──────────────────────────┬────────────────────────────────┐

109 │ *Business type* │ [marketplace or SaaS platform] │

110 ├──────────────────────────┼────────────────────────────────┤

111 │ *Sellers/providers* │ [who they are] │

112 ├──────────────────────────┼────────────────────────────────┤

113 │ *Buyers/customers* │ [who they are] │

114 ├──────────────────────────┼────────────────────────────────┤

115 │ *How money flows* │ [payment flow] │

116 ├──────────────────────────┼────────────────────────────────┤

117 │ *Fee structure* │ [fee details] │

118 └──────────────────────────┴────────────────────────────────┘

119

120Based on this, I'd recommend: [configuration description in plain language]

121

122I'll proceed with this unless you'd like to correct anything.

123```

124

125For MEDIUM confidence items, append: “I’m also assuming [X] — sound right?”

126

127If the agent flags “not-connect” (business doesn’t need Connect), ask the user:

128

129```

130Based on my research, your business may not need Stripe Connect — a standard Stripe integration might be a better fit.

131```

132

133Options:

134

135- “Proceed with Connect anyway” — continue discovery

136- “Explore standard integration instead” — exit this skill, suggest standard Stripe integration

137

138Update the checklist:

139

140```

141 [x] Learn about your business

142 [ ] Scan your project

143 [ ] Recommend configuration + charge pattern

144 [ ] Produce recommendation plan

145```

146

147**1f. Validate fee economics (ALWAYS runs, even on auto-filled values)**

148

149If the platform fee (from auto-fill or user input) appears low AND any of these conditions apply:

150

151- Charge pattern is destination or separate (platform pays Stripe fees by default)

152- Charge pattern is direct AND fees_collector: "application" (platform still pays Stripe fees)

153

154Then:

155

156- ALWAYS show a margin warning regardless of how the fee was obtained

157- Warn: “Your platform fee might be below Stripe’s processing fees at standard rates. Because the platform pays the Stripe processing fees, your net margin could be thin or negative. Check [stripe.com/pricing](https://stripe.com/pricing) for your region’s rates.”

158- If the charge pattern is destination or direct (with fees_collector: "application"): The platform needs to calculate application_fee_amount as platform fee + estimated Stripe processing fee (so that the platform preserves its margin) and (if the platform owns pricing) use the [Platform Pricing Tool](https://dashboard.stripe.com/settings/connect/platform_pricing)

159- If the charge pattern is separate (separate charges and transfers): application_fee_amount is NOT compatible. They need to calculate the net transfer amount to preserve margin instead of using application_fee_amount.

160- Recommend monitoring the [margin report](https://docs.stripe.com/connect/margin-reports.md) in the Stripe Dashboard

161

162This check MUST run even when the fee was auto-filled with HIGH confidence. The user needs to understand the fee economics before proceeding.

163

164#### Step 2 — Auto-detect project context

165

166Run this AFTER Step 1 (or in parallel if the user said “scan my codebase”). Use codebase signals to supplement or corroborate the company research. **Don’t ask before scanning — just scan.**

167

1681. **Existing Connect config**: Check for connect-recommend-plan.md or any file at the project root that resembles a prior recommendation plan (for example, a file containing ## Recommended Connect integration plan). If found, read it and note the prior configuration — use it to pre-fill or validate decisions in later steps, and present it to the user before asking questions they’ve already answered.

1692. **Existing Stripe integration patterns**: Use Grep to search for Connect-specific patterns already in the codebase:

170 - Connected account creation or references (connected_account, account_id, stripe_account)

171 - Charge patterns in use (destination, on_behalf_of, transfer_data, separate_charges)

172 - Transfer or payout logic (transfers.create, payouts.create)

173 - Webhook handlers for Connect events (account.updated, capability, payout)

174 - Existing application_fee_amount usage

175

176If codebase signals contradict the company research, note the discrepancy and ask the user to clarify.

177

178Present findings briefly (don’t repeat what Step 1 already covered):

179

180```

181Project scan:

182- Existing Connect plan: [found at path / not found]

183- Existing Connect integration: [patterns found / not found]

184```

185

186If a prior plan was found, ask the user:

187

188```

189I found an existing Connect recommendation plan at [path].

190```

191

192Options:

193

194- “Use it as a starting point” — pre-fill all decisions from the prior plan, then confirm each with the user in Step 3

195- “Start fresh” — ignore the prior plan and run full discovery

196

197Update the checklist:

198

199```

200 [x] Learn about your business

201 [x] Scan your project

202 [ ] Recommend configuration + charge pattern

203 [ ] Produce recommendation plan

204```

205

206#### Step 3 — Ask remaining discovery questions

207

208For any dimension not already filled with HIGH confidence from Step 1, ask the corresponding question to the user. Skip dimensions that were auto-filled or explicitly confirmed.

209

210**Read <references/discovery-questions.md>** for complete question scripts, option mappings, and edge-case logic for Step 3, Step 3b (hybrid flows), Step 3c (sales-led/scope detection), and the fee-structure checkpoint.

211

212If Step 1 was skipped entirely, ask all six discovery questions one at a time:

213

214- Q1: Business model

215- Q2: Parties in the platform

216- Q3: Payment flow

217- Q4: Dashboard and onboarding preference

218- Q5: Dispute and refund ownership + risk management + loss liability

219- Q6: Fee structure + application_fee_amount calculation

220

221Critical guardrails (must enforce in all discovery paths):

222

223- For marketplace or intermediary checkout flows, default to destination charges unless behavior clearly indicates each seller runs their own checkout or payment relationship.

224- If the business mixes its own-brand sales with marketplace or intermediary flows, trigger Step 3b hybrid-flow handling and map each flow to its own charge-pattern and responsibility settings.

225- If the user needs hold-and-release timing, recommend separate charges and transfers (destination charges can’t hold funds and aren’t appropriate for hold-and-release behavior).

226- For SaaS with independent sellers that own customer relationships, use full dashboard + direct charges + embedded onboarding.

227- If the user asks “what account type should I use?”, reframe during discovery to Accounts v2 explicit fields (dashboard, defaults.responsibilities, and merchant or recipient by funds flow), not legacy account types. Read <references/account-types.md> for the full v2 configuration reference.

228- When describing low-margin scenarios, present warnings and risks before mitigation steps.

229- If dashboard: "none" is selected, include a concise full-scope warning about custom UI responsibilities.

230- For destination or separate recommendations with losses_collector: "application", explain the causal chain: platform owns negative balance liability and connected-account negative balances enable dispute-time transfer reversals.

231- Keep risk management and negative balance liability as separate decisions.

232- Trigger Step 3c when enterprise or sales-led signals appear (on_behalf_of, cross-border complexity, non-Connect products, or sales-gated configs).

233

234Fee structure checkpoint before Step 4:

235

2361. Confirm fee type and fee amount

2372. Confirm how application_fee_amount is calculated

2383. Confirm whether a margin warning is required

2394. Include stripe.com/pricing link in output context

240

241#### Step 4 — Generate recommendation

242

243Read the decision matrix at <references/decision-matrix.md> and apply it to the user’s answers. For charge pattern details, read <references/charge-patterns.md>.

244

245**Step 4a — Compatibility validation (MANDATORY before presenting recommendation)**

246

247Read <references/compatibility-matrix.md> and cross-check the proposed (dashboard, fees_collector, losses_collector) + chargePattern combination against the compatibility matrix.

248

2491. **BLOCKED combination?** Do NOT present it. Output a visible BLOCKED warning with ALL of these:

250

251 - The exact blocked config tuple (for example, losses_collector: "stripe" + destination charges)

252 - A 2-3 sentence explanation of the MECHANISM of failure (for example, “With destination charges and a dispute, Stripe debits the disputed amount from the platform’s balance. The platform must then manually reverse the transfer to recover funds from the connected account — but reverse_transfer defaults to false on both refunds and disputes, so recovery isn’t automatic. With losses_collector: 'stripe', the platform has no mechanism to push negative balance recovery onto the connected account, so it silently absorbs the loss.”)

253 - The recommended fix (nearest ALLOWED alternative — usually switching losses_collector to "application" or switching to direct charges) Then re-run the recommendation with the corrected configuration.

254

2552. **CAUTION combination?** Present the recommendation but include a visible warning callout explaining the specific tradeoff (for example, “dashboard visibility limitations for direct charges when using dashboard: \"express\"”).

256

2573. **Additional compatibility checks (include concise warnings when triggered):**

258

259 - If the user mentioned **OAuth** for connecting accounts, include a 1-2 sentence warning that accounts can disconnect and recommend embedded onboarding for stronger platform control.

260 - If dashboard: "none", include a concise warning that the platform must own onboarding and remediation, refund and dispute flows, and earnings and payout views; recommend Express dashboard with embedded components as a lower-maintenance alternative.

261 - If user mentions **Billing, Invoicing, or Payment Links** with destination charges, include a concise compatibility warning and recommend the nearest supported path.

262 - If dashboard: "full" + fees_collector: "stripe" + charge pattern is destination or separate, treat as BLOCKED. Do NOT present this configuration. Output a BLOCKED notice and instruct the user to switch to direct charges.

263 - If dashboard: "full" + fees_collector: "application", treat as SALES-GATED regardless of charge pattern. Do NOT recommend for self-serve paths. Redirect to [Stripe sales](https://stripe.com/contact/sales).

264 - If dashboard: "express" + fees_collector: "stripe", treat as BLOCKED and recommend either switching to full dashboard (Stripe-owned pricing) or platform-owned pricing.

265

2664. **Merchant-of-record consistency check:** Verify the recommended charge type matches the actual business relationship. Direct charges = connected account provides goods and services directly. Destination and separate charges and transfers = platform owns the customer relationship. Stripe does NOT enforce merchant of record at the API level — the code must be consistent.

267

2685. **Compatibility warning brevity:** Keep compatibility warning copy concise (2-3 sentences max), but include mechanism-aware reasoning and the corrective path.

269

270**Step 4b — Recommend embedded components**

271

272Embedded components are recommended, as they enable platforms to build full-featured dashboards of their own, especially when accounts are configured with dashboard: "none" and even if accounts are configured with (dashboard: "full" or dashboard: "express"). Select components based on user needs:

273

274Baseline (always include):

275

276- account_onboarding

277- notification_banner (required; keeps connected accounts healthy and enabled as requirements evolve)

278- account_management

279

280Common additions:

281

282- Transaction history → payments (use payment_details if building a custom payments list)

283- Disputes → included with payments but can use disputes_list if also building a standalone disputes page

284- Payout operations and earnings → payouts

285- Reporting and reconciliation → balance_report, payout_reconciliation_report

286

287Charge-pattern compatibility caveats:

288

289- Destination charges: payment and dispute views show reduced detail.

290- Separate charges and transfers: payment and dispute views show reduced detail.

291- Direct: payment and dispute views operate with full fidelity.

292

293Out of scope component families:

294

295- Issuing, Treasury, and Capital and Tax component sets (route through Step 3c scope handling).

296

297Be prepared to output a list of embedded components in the next step.

298

299Update the checklist:

300

301```

302 [x] Learn about your business

303 [x] Scan your project

304 [x] Recommend configuration + charge pattern

305 [ ] Produce recommendation plan

306```

307

308#### Step 5 — Generate recommendation plan

309

310**Read <references/recommendation-template.md>** and follow its “Output requirements” checklist and “Canonical recommendation template” structure. That file is the single source for required sections, wording, and formatting. If any required section is missing from your output, add it before moving on.

311

312Then ask the user:

313

314```

315Does this recommendation look right?

316```

317

318Options (max 4 — options hard limit):

319

320- “Looks good” — proceed to Step 6

321- “Change something” — ask which aspect to change (dashboard or responsibility settings, charge pattern, fee structure, or fee calculation) then re-ask the relevant question

322- “Explain more about the options” — read reference docs and explain alternatives

323

324Generate the final recommendation plan. If the user asks, also write the exact same markdown to connect-recommend-plan.md at the project root.

325

326When they accept the plan, update the checklist:

327

328```

329 [x] Learn about your business

330 [x] Scan your project

331 [x] Recommend configuration + charge pattern

332 [x] Produce recommendation plan

333```

334

335#### Step 6 — Explain what belongs in code vs Dashboard, and next actions

336

337Show a compact summary of decisions and immediate implementation priorities.

338

339Briefly explain:

340

341- **In your code**: charge pattern behavior, application_fee_amount math, transfer and reversal handling, and webhook handlers

342- **In the Stripe Dashboard**: platform profile settings, pricing tool configuration, connected-account visibility, Radar for Platforms settings, and operational monitoring

343- **During onboarding and runtime**: capability activation, payouts readiness, and account-state transitions

344

345**IMPORTANT: Always end with AskUserQuestion.** Never end with passive text.

346

347Use AskUserQuestion:

348

349```

350What would you like to do next?

351```

352

353Options:

354

355- “Refine a decision” — adjust dashboard, responsibilities, charge pattern, or fee model

356- “Expand implementation steps” — provide a deeper technical rollout checklist

357- “Generate connect-recommend-plan.md and build” — write the plan to a markdown file and handoff to a coding agent

358

In the file

SKILL.md2,786 words

Files9

LicenceMIT

Why you can read it

Nothing in a skill executes. The client loads the text and the model follows it, so a skill can be audited the way a runbook is — by reading it.

What it costs in context

Skills are not billed by the call. They are paid for in context: every token the instructions occupy is a token your code, your diff and your conversation cannot use. Here is what this one takes and when it takes it.

≈220

always loaded

The name and description, so the model knows the skill exists and when to reach for it.

35,630

on trigger

The instruction body and 8 supporting files, read only when the skill fires.

17.9%

of a 200k window

Ten skills this size would take about 179% of the window before you open a file.

050k100k150k200k context window

35.9k tokens, estimated from the bundle at four bytes to the token, held for the rest of the session once it triggers. Heavy. Teams tend to install this one per project rather than globally, and load it only when the job comes up.

Servers bill, skills cost

A server charges by the month. A skill charges once per session, in context, and then keeps charging it for as long as the session lives.

Before and after

The same question, put to the same model twice: once as it comes, and once with these instructions loaded.

No worked example has been published for this skill yet.

Adoption

Installsnone yet

Ratingno reviews yet

The procedure it runs

The procedure has not been published here. It is in the skill’s own SKILL.md, which its author has not sent to the marketplace yet.

Prose, not code

These steps are written for a model to follow, not executed by a runtime. It can still be told to skip one, and it will say so when it does.

Servers it uses

None. This skill calls no MCP servers at all.

Everything it needs is in the instructions, so it works in a project with nothing connected — the model reads the file and changes how it works with what it can already reach.

It writes no files and reaches no network. All it changes is how the model reasons and writes.

What it asks for

Writes filesno

Network accessno

Read from the allowed-tools line of this skill’s own SKILL.md. A skill grants no permissions of its own — it can only ask for tools your client already has.

What it will not do

Every skill is narrow, and the useful ones say where they stop. These are the jobs this one is the wrong tool for.

What this skill is not for has not been published here. Nothing is implied by that: it is a section the author has not filled in.

If this is not it

18 other skills in Finance & Commerce

What is in the bundle

9 files, 143.4 kB on disk. A bundle is text throughout: the instructions the model reads, plus the templates it fills in.

SKILL.md21.2 kB
references/account-types.md14.9 kB
references/charge-patterns.md11.7 kB
references/company-researcher.md7.8 kB
references/compatibility-matrix.md16.5 kB
references/decision-matrix.md34.5 kB
references/discovery-questions.md16.4 kB
references/recommendation-template.md13.8 kB
references/terminology-rules.md6.6 kB

What is not in it

No dependencies and nothing executable: a skill is text the agent reads, so the bundle is 9 files you can review in full before installing. The MIT licence covers the templates and examples as well as the instructions.

Install

Installing copies the bundle into your project. Nothing runs at install time — the files sit on disk until the model reads them.

$29 once

Connect Recommend · MIT · stripe

one-time

Price$29 once

LicenceMIT — the author’s, unchanged by this purchase

Paid throughStripe, once, on the card you add at the checkout

Keeps workingfor good — the files are yours once they are on disk

Updatesevery update its author ships, delivered through this account

You can read the whole bundle before paying — the SKILL.md above is the product, not a preview of it. What the money buys is the delivery: the folder packaged and handed to your machine by key, every update its author ships, and our support if it does not do what this listing says. The terms of use are MIT, set by the author and unchanged by buying it here.

Payment runs through Stripe, on a page like this one rather than a redirect. Once there is an account it joins the same mcprush invoice as everything else you run, so there is never a second card to enter.

Which clients pick it up on their own

A skill is a folder of text. A client with a skills folder reads it without being told; everywhere else the same text works, it is just handed to the model rather than found.

Claude Code.claude/skills/

Claude Desktop

ChatGPT

Cursor.cursor/skills/

VS Code.github/skills/

Codex CLI.agents/skills/

Gemini CLI.gemini/skills/

Grok.grok/skills/

Zed.agents/skills/

Windsurf.windsurf/skills/

Agent SDK.claude/skills/

HTTP / API

This release

Versionnot versioned

Publishedno release date on file

Price$29

Referencestripe/connect-recommend

Versions

Its author publishes no version number, so there is nothing here to pin to: what you install is the folder as it stands today. Instructions change more often than APIs do — a skill can be rewritten entirely without anything it depends on moving.

No earlier releases have been published to the marketplace.

Pinning

Nothing to pin to: this skill carries no version number of its own. What you install is what the folder holds on the day you install it.

Reviews

—no reviews yet · no installs yet

Nobody has reviewed this skill yet. The rating is the mean of the reviews written here, so there is none until somebody writes the first.

Who can post

Only accounts that have had the skill installed for fourteen days, so a review is written after living with it rather than after reading it. Publishers may reply once.

Who wrote it

stripe

Publishes on mcprush.

0 servers listed2 skills listednot claimed

Profile

Publisher

Servers0