Output format·Finance & Commerce·v1.0.0

Flowglad Setup

Name: Flowglad Setup
Author: flowglad

Install and configure the Flowglad SDK for Next.js, Express, and React applications.

You say

Buy it · $19 Read it before you buy $19 Written by flowglad · unverified publisher

Context cost: 4.9k tokensestimated from the bundle, loaded when it triggers
Bundle: 1 file · 19.7 kBtext throughout, nothing executable
Licence: MITpaid listing
Last change: —v1.0.0
Servers it uses: Noneruns standalone

What it does

Install and configure the Flowglad SDK for Next.js, Express, and React applications. Use this skill when adding billing to an app, setting up Flowglad for the first time, or configuring SDK providers and route handlers.

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-commercenextjsreact

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.md19.7 kB · 799 lines

--- name: flowglad-setup description: Install and configure the Flowglad SDK for Next.js, Express, and React applications. Use this skill when adding billing to an app, setting up Flowglad for the first time, or configuring SDK providers and route handlers. license: MIT metadata: author: flowglad version: "1.0.0" ---

10<!--

11@flowglad/skill

12sources_reviewed: 2026-02-24T21:27:00Z

13source_files:

14 - platform/docs/quickstart.mdx

15 - platform/docs/sdks/setup.mdx

16 - platform/docs/sdks/introduction.mdx

17 - platform/docs/sdks/nextjs.mdx

18 - platform/docs/sdks/server.mdx

19 - platform/docs/snippets/setup-nextjs.mdx

20 - platform/docs/snippets/setup-react.mdx

21 - platform/docs/snippets/setup-server.mdx

22-->

24# Flowglad Setup

26## Abstract

28This skill covers installing and configuring the Flowglad SDK for Next.js, Express, and React applications. It includes framework detection, package installation, environment setup, server factory creation, route handler setup, and provider configuration.

30---

32## Table of Contents

341. [Framework Detection](#1-framework-detection) — **CRITICAL**

35 - 1.1 [Detecting the Framework](#11-detecting-the-framework)

362. [Next.js Setup](#2-nextjs-setup) — **CRITICAL**

37 - 2.1 [Package Installation](#21-package-installation)

38 - 2.2 [Environment Variables](#22-environment-variables)

39 - 2.3 [Server Factory Creation](#23-server-factory-creation)

40 - 2.4 [API Route Handler](#24-api-route-handler)

41 - 2.5 [FlowgladProvider Setup](#25-flowgladprovider-setup)

423. [Express Setup](#3-express-setup) — **HIGH**

43 - 3.1 [Package Installation](#31-package-installation)

44 - 3.2 [Server Factory Creation](#32-server-factory-creation)

45 - 3.3 [Express Router Setup](#33-express-router-setup)

464. [React Setup (Other Frameworks)](#4-react-setup-other-frameworks) — **HIGH**

47 - 4.1 [Package Installation](#41-package-installation)

48 - 4.2 [FlowgladProvider Setup](#42-flowgladprovider-setup)

49 - 4.3 [Backend Requirements](#43-backend-requirements)

505. [Customer ID Mapping](#5-customer-id-mapping) — **CRITICAL**

51 - 5.1 [Using Your App's User ID](#51-using-your-apps-user-id)

52 - 5.2 [Organization vs User Customers](#52-organization-vs-user-customers)

536. [getCustomerDetails Callback](#6-getcustomerdetails-callback) — **HIGH**

54 - 6.1 [Required Fields](#61-required-fields)

55 - 6.2 [Database Integration](#62-database-integration)

57---

59## 1. Framework Detection

61**Impact: CRITICAL**

63Before beginning setup, detect which framework the user is using to ensure correct package installation and configuration.

65### 1.1 Detecting the Framework

67**Impact: CRITICAL (incorrect detection leads to wrong SDK usage)**

69Check for framework-specific configuration files to determine the correct setup path.

71**Detection Rules:**

73```text

74Next.js: next.config.js OR next.config.ts OR next.config.mjs exists

75Express: "express" in package.json dependencies

76React (CRA): "react-scripts" in package.json dependencies

77Vite React: "vite" in package.json devDependencies AND "react" in dependencies

78```

80**Incorrect: assuming Next.js without checking**

82```typescript

83// Don't assume the framework - always verify first

84import { FlowgladServer } from '@flowglad/nextjs/server'

85// This will fail if the user is using Express or plain React

86```

88**Correct: check framework before recommending packages**

90```bash

91# Check for Next.js

92ls next.config.* 2>/dev/null && echo "Next.js detected"

94# Check for Express (in package.json)

95grep -q '"express"' package.json && echo "Express detected"

96```

98After detection, proceed to the appropriate setup section.

100---

101

102## 2. Next.js Setup

103

104**Impact: CRITICAL**

105

106Next.js is the primary supported framework with the most streamlined integration.

107

108### 2.1 Package Installation

109

110**Impact: CRITICAL (wrong packages = broken integration)**

111

112**Incorrect: installing individual packages separately**

113

114```bash

115# Don't install packages piecemeal

116npm install @flowglad/server

117npm install @flowglad/react

118# Missing the unified Next.js package

119```

120

121**Correct: install the Next.js package (includes server and react)**

122

123```bash

124bun add @flowglad/nextjs @flowglad/react

125```

126

127The @flowglad/nextjs package re-exports server functionality and is designed for Next.js App Router.

128

129### 2.2 Environment Variables

130

131**Impact: CRITICAL (missing env vars = authentication failures)**

132

133**Incorrect: hardcoding API key**

134

135```typescript

136// SECURITY RISK: Never hardcode secrets

137const flowglad = new FlowgladServer({

138 apiKey: 'sk_live_abc123...',

139 // ...

140})

141```

142

143**Correct: use environment variable**

144

145```bash

146# .env.local

147FLOWGLAD_SECRET_KEY=sk_live_your_secret_key_here

148```

149

150```typescript

151// The SDK automatically reads FLOWGLAD_SECRET_KEY from process.env

152// No need to pass apiKey explicitly

153const flowglad = new FlowgladServer({

154 customerExternalId,

155 getCustomerDetails,

156})

157```

158

159The SDK automatically reads FLOWGLAD_SECRET_KEY from the environment. You only need to pass apiKey explicitly if using a different environment variable name.

160

161### 2.3 Server Factory Creation

162

163**Impact: CRITICAL (incorrect factory = broken billing operations)**

164

165Create a factory function that returns a FlowgladServer instance scoped to a specific customer.

166

167**Incorrect: creating a single shared instance**

168

169```typescript

170// lib/flowglad.ts

171// BAD: Single shared instance loses customer context

172export const flowglad = new FlowgladServer({

173 // No customerExternalId - will fail for customer-specific operations

174})

175```

176

177**Correct: factory function that creates scoped instances**

178

179```typescript

180// lib/flowglad.ts

181import { FlowgladServer } from '@flowglad/nextjs/server'

182import { db } from '@/db'

183

184export const flowglad = (customerExternalId: string) => {

185 return new FlowgladServer({

186 customerExternalId,

187 getCustomerDetails: async (externalId: string) => {

188 const user = await db.users.findUnique({

189 where: { id: externalId },

190 })

191 if (!user) {

192 throw new Error(User not found: ${externalId})

193 }

194 return {

195 email: user.email,

196 name: user.name || user.email,

197 }

198 },

199 })

200}

201```

202

203The factory pattern ensures each request gets a properly scoped server instance.

204

205### 2.4 API Route Handler

206

207**Impact: CRITICAL (missing route = SDK cannot communicate with Flowglad)**

208

209Create a catch-all API route to handle Flowglad SDK requests from the frontend.

210

211**Incorrect: manual route implementation**

212

213```typescript

214// app/api/flowglad/route.ts

215// BAD: Manual implementation misses many endpoints

216export async function POST(req: Request) {

217 const body = await req.json()

218 // Incomplete - missing proper routing, validation, etc.

219 return Response.json({ error: 'Not implemented' })

220}

221```

222

223**Correct: use nextRouteHandler with catch-all route**

224

225```typescript

226// app/api/flowglad/[...path]/route.ts

227import { nextRouteHandler } from '@flowglad/nextjs/server'

228import { auth } from '@/lib/auth' // Your auth solution

229import { flowglad } from '@/lib/flowglad'

230

231export const { GET, POST } = nextRouteHandler({

232 flowglad,

233 getCustomerExternalId: async (req) => {

234 // Extract the authenticated user's ID from your auth system

235 const session = await auth()

236 if (!session?.user?.id) {

237 throw new Error('Unauthorized')

238 }

239 return session.user.id

240 },

241})

242```

243

244**Important:** The route must be a catch-all ([...path]) to handle all Flowglad API subroutes.

245

246### 2.5 FlowgladProvider Setup

247

248**Impact: CRITICAL (missing provider = hooks don't work)**

249

250Wrap your application with FlowgladProvider to enable the useBilling hook.

251

252**Incorrect: not wrapping the app**

253

254```tsx

255// app/layout.tsx

256// BAD: useBilling will throw without FlowgladProvider

257export default function RootLayout({ children }) {

258 return (

259 <html>

260 <body>{children}</body>

261 </html>

262 )

263}

264```

265

266**Correct: wrap with FlowgladProvider**

267

268```tsx

269// app/layout.tsx

270import { FlowgladProvider } from '@flowglad/react'

271

272export default function RootLayout({

273 children,

274}: {

275 children: React.ReactNode

276}) {

277 return (

278 <html>

279 <body>

280 <FlowgladProvider>{children}</FlowgladProvider>

281 </body>

282 </html>

283 )

284}

285```

286

287For apps with a custom API base URL:

288

289```tsx

290<FlowgladProvider baseURL="https://api.yourapp.com">

291 {children}

292</FlowgladProvider>

293```

294

295---

296

297## 3. Express Setup

298

299**Impact: HIGH**

300

301For Express applications, use the @flowglad/server package with the Express router helper.

302

303### 3.1 Package Installation

304

305**Impact: HIGH (wrong package = missing Express utilities)**

306

307**Incorrect: installing the Next.js package for Express**

308

309```bash

310# Wrong package for Express

311npm install @flowglad/nextjs

312```

313

314**Correct: install the server package**

315

316```bash

317bun add @flowglad/server

318```

319

320### 3.2 Server Factory Creation

321

322**Impact: HIGH (same pattern as Next.js)**

323

324**Incorrect: not providing getCustomerDetails**

325

326```typescript

327// utils/flowglad.ts

328// BAD: Missing getCustomerDetails - customer creation will fail

329export const flowglad = (customerExternalId: string) => {

330 return new FlowgladServer({

331 customerExternalId,

332 // getCustomerDetails is required!

333 })

334}

335```

336

337**Correct: provide complete factory**

338

339```typescript

340// utils/flowglad.ts

341import { FlowgladServer } from '@flowglad/server'

342import { db } from '../db'

343

344export const flowglad = (customerExternalId: string) => {

345 return new FlowgladServer({

346 customerExternalId,

347 getCustomerDetails: async (externalId: string) => {

348 const user = await db.users.findOne({ id: externalId })

349 if (!user) {

350 throw new Error(User not found: ${externalId})

351 }

352 return {

353 email: user.email,

354 name: user.name,

355 }

356 },

357 })

358}

359```

360

361### 3.3 Express Router Setup

362

363**Impact: HIGH (incorrect setup = broken API routes)**

364

365**Incorrect: manually handling each route**

366

367```typescript

368// routes/flowglad.ts

369// BAD: Manual route handling is error-prone and incomplete

370import express from 'express'

371

372const router = express.Router()

373

374router.post('/checkout', async (req, res) => {

375 // Manual implementation - missing validation, error handling, etc.

376})

377

378export { router }

379```

380

381**Correct: use expressRouter helper**

382

383```typescript

384// routes/flowglad.ts

385import { expressRouter } from '@flowglad/server/express'

386import type { Request } from 'express'

387import { flowglad } from '../utils/flowglad'

388

389export const flowgladRouter = expressRouter({

390 flowglad,

391 getCustomerExternalId: async (req: Request) => {

392 // Extract customer ID from your auth middleware

393 const userId = req.user?.id

394 if (!userId) {

395 throw new Error('Unauthorized')

396 }

397 return userId

398 },

399})

400```

401

402Mount the router in your Express app:

403

404```typescript

405// index.ts

406import express from 'express'

407import { flowgladRouter } from './routes/flowglad'

408

409const app = express()

410

411app.use(express.json())

412app.use('/api/flowglad', flowgladRouter)

413

414app.listen(3000)

415```

416

417---

418

419## 4. React Setup (Other Frameworks)

420

421**Impact: HIGH**

422

423For React apps not using Next.js (Create React App, Vite, etc.), you need both frontend and backend setup.

424

425### 4.1 Package Installation

426

427**Impact: HIGH (frontend package only)**

428

429```bash

430bun add @flowglad/react

431```

432

433### 4.2 FlowgladProvider Setup

434

435**Impact: HIGH (must point to your backend)**

436

437**Incorrect: using FlowgladProvider without baseURL in non-Next.js apps**

438

439```tsx

440// App.tsx

441// BAD: Assumes /api/flowglad exists, but CRA/Vite don't have API routes

442import { FlowgladProvider } from '@flowglad/react'

443

444function App() {

445 return (

446 <FlowgladProvider>

447 <MyApp />

448 </FlowgladProvider>

449 )

450}

451```

452

453**Correct: specify your backend URL**

454

455```tsx

456// App.tsx

457import { FlowgladProvider } from '@flowglad/react'

458

459function App() {

460 return (

461 <FlowgladProvider baseURL="https://api.yourapp.com">

462 <MyApp />

463 </FlowgladProvider>

464 )

465}

466```

467

468### 4.3 Backend Requirements

469

470**Impact: HIGH (frontend SDK requires backend)**

471

472The @flowglad/react package makes API calls to your backend. You must have a backend that:

473

4741. Handles Flowglad API routes (use @flowglad/server with Express, Fastify, etc.)

4752. Authenticates requests and extracts customer IDs

4763. Forwards requests to Flowglad's API

477

478**Incorrect: trying to use Flowglad client-side only**

479

480```tsx

481// BAD: Cannot call Flowglad API directly from browser

482// API keys should never be exposed to the client

483const billing = await fetch('https://api.flowglad.com/v1/...', {

484 headers: { Authorization: Bearer ${FLOWGLAD_SECRET_KEY} }, // SECURITY RISK

485})

486```

487

488**Correct: frontend calls your backend, backend calls Flowglad**

489

490```text

491Browser (React) → Your Backend (Express/etc) → Flowglad API

492 ↑ ↑ ↑

493 @flowglad/react @flowglad/server Flowglad servers

494```

495

496---

497

498## 5. Customer ID Mapping

499

500**Impact: CRITICAL**

501

502Flowglad uses customerExternalId to link billing data to your application's users. This is YOUR app's user ID, not a Flowglad-generated ID.

503

504### 5.1 Using Your App's User ID

505

506**Impact: CRITICAL (wrong ID = billing attached to wrong user)**

507

508**Incorrect: generating a new ID for Flowglad**

509

510```typescript

511// BAD: Don't create separate IDs for Flowglad

512const flowgladCustomerId = crypto.randomUUID()

513

514export const flowglad = (userId: string) => {

515 return new FlowgladServer({

516 customerExternalId: flowgladCustomerId, // Wrong! Not tied to your user

517 // ...

518 })

519}

520```

521

522**Correct: use your existing user/organization ID**

523

524```typescript

525// Your user.id IS the customerExternalId

526export const flowglad = (customerExternalId: string) => {

527 return new FlowgladServer({

528 customerExternalId, // This is your app's user.id or org.id

529 getCustomerDetails: async (externalId) => {

530 // externalId here is the same as customerExternalId

531 const user = await db.users.findUnique({

532 where: { id: externalId },

533 })

534 return { email: user.email, name: user.name }

535 },

536 })

537}

538

539// Usage: pass your user's ID directly

540const billing = await flowglad(session.user.id).getBilling()

541```

542

543### 5.2 Organization vs User Customers

544

545**Impact: HIGH (affects multi-tenant billing)**

546

547For B2B apps with team/organization billing, use the organization ID as the customer ID.

548

549**Incorrect: using user ID for organization billing**

550

551```typescript

552// BAD: Each team member creates separate billing

553const getCustomerExternalId = async (req) => {

554 const session = await auth()

555 return session.user.id // Wrong for team billing!

556}

557```

558

559**Correct: use organization ID for team billing**

560

561```typescript

562// For B2B apps with team billing

563const getCustomerExternalId = async (req) => {

564 const session = await auth()

565 // Return the organization ID, not the user ID

566 return session.user.organizationId

567}

568```

569

570Choose your customer ID strategy based on your billing model:

571

572| Billing Model | customerExternalId | Example |

573|---------------|-------------------|---------|

574| Per-user (B2C) | user.id | Consumer SaaS |

575| Per-team (B2B) | organization.id | Team collaboration tools |

576| Per-workspace | workspace.id | Multi-workspace apps |

577

578---

579

580## 6. getCustomerDetails Callback

581

582**Impact: HIGH**

583

584The getCustomerDetails callback is called when Flowglad needs to create a new customer record. It must return the customer's email and name.

585

586### 6.1 Required Fields

587

588**Impact: HIGH (missing fields = customer creation fails)**

589

590**Incorrect: returning incomplete data**

591

592```typescript

593getCustomerDetails: async (externalId) => {

594 const user = await db.users.findUnique({ where: { id: externalId } })

595 return {

596 email: user.email,

597 // Missing name field!

598 }

599}

600```

601

602**Correct: return both email and name**

603

604```typescript

605getCustomerDetails: async (externalId) => {

606 const user = await db.users.findUnique({ where: { id: externalId } })

607 if (!user) {

608 throw new Error(User not found: ${externalId})

609 }

610 return {

611 email: user.email,

612 name: user.name || user.email, // Fallback to email if no name

613 }

614}

615```

616

617### 6.2 Database Integration

618

619**Impact: HIGH (callback must access your user data)**

620

621The callback receives the customerExternalId and should look up the corresponding user in your database.

622

623**Incorrect: hardcoding customer details**

624

625```typescript

626// BAD: Hardcoded values don't represent real users

627getCustomerDetails: async (externalId) => {

628 return {

629 email: 'test@example.com',

630 name: 'Test User',

631 }

632}

633```

634

635**Correct: query your database**

636

637```typescript

638// Drizzle ORM example

639import { db } from '@/db'

640import { users } from '@/db/schema'

641import { eq } from 'drizzle-orm'

642

643getCustomerDetails: async (externalId) => {

644 const [user] = await db

645 .select({ email: users.email, name: users.name })

646 .from(users)

647 .where(eq(users.id, externalId))

648 .limit(1)

649

650 if (!user) {

651 throw new Error(User not found: ${externalId})

652 }

653

654 return {

655 email: user.email,

656 name: user.name || 'Unknown',

657 }

658}

659```

660

661```typescript

662// Prisma example

663import { prisma } from '@/lib/prisma'

664

665getCustomerDetails: async (externalId) => {

666 const user = await prisma.user.findUnique({

667 where: { id: externalId },

668 select: { email: true, name: true },

669 })

670

671 if (!user) {

672 throw new Error(User not found: ${externalId})

673 }

674

675 return {

676 email: user.email,

677 name: user.name || user.email,

678 }

679}

680```

681

682---

683

684## Complete Next.js Setup Example

685

686Here's a complete setup for a Next.js application:

687

688**1. Install packages:**

689

690```bash

691bun add @flowglad/nextjs @flowglad/react

692```

693

694**2. Set environment variable:**

695

696```bash

697# .env.local

698FLOWGLAD_SECRET_KEY=sk_live_your_key_here

699```

700

701**3. Create server factory (lib/flowglad.ts):**

702

703```typescript

704import { FlowgladServer } from '@flowglad/nextjs/server'

705import { db } from '@/db'

706import { users } from '@/db/schema'

707import { eq } from 'drizzle-orm'

708

709export const flowglad = (customerExternalId: string) => {

710 return new FlowgladServer({

711 customerExternalId,

712 getCustomerDetails: async (externalId) => {

713 const [user] = await db

714 .select({ email: users.email, name: users.name })

715 .from(users)

716 .where(eq(users.id, externalId))

717 .limit(1)

718

719 if (!user) {

720 throw new Error(User not found: ${externalId})

721 }

722

723 return {

724 email: user.email,

725 name: user.name || user.email,

726 }

727 },

728 })

729}

730```

731

732**4. Create API route (app/api/flowglad/[...path]/route.ts):**

733

734```typescript

735import { nextRouteHandler } from '@flowglad/nextjs/server'

736import { auth } from '@/lib/auth'

737import { flowglad } from '@/lib/flowglad'

738

739export const { GET, POST } = nextRouteHandler({

740 flowglad,

741 getCustomerExternalId: async () => {

742 const session = await auth()

743 if (!session?.user?.id) {

744 throw new Error('Unauthorized')

745 }

746 return session.user.id

747 },

748})

749```

750

751**5. Add FlowgladProvider (app/layout.tsx):**

752

753```tsx

754import { FlowgladProvider } from '@flowglad/react'

755

756export default function RootLayout({

757 children,

758}: {

759 children: React.ReactNode

760}) {

761 return (

762 <html>

763 <body>

764 <FlowgladProvider>{children}</FlowgladProvider>

765 </body>

766 </html>

767 )

768}

769```

770

771**6. Use in components:**

772

773```tsx

774'use client'

775

776import { useBilling } from '@flowglad/react'

777

778export function BillingStatus() {

779 const { loaded, customer, currentSubscription } = useBilling()

780

781 if (!loaded) return <div>Loading...</div>

782 if (!customer) return <div>Please log in</div>

783

784 return (

785 <div>

786 <p>Plan: {currentSubscription?.product?.name || 'Free'}</p>

787 </div>

788 )

789}

790```

791

792---

793

794## References

795

796- [Flowglad Documentation](https://docs.flowglad.com)

797- [Next.js Integration Guide](https://docs.flowglad.com/frameworks/nextjs)

798- [Express Integration Guide](https://docs.flowglad.com/frameworks/express)

799

In the file

SKILL.md2,390 words

Files1

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.

≈80

always loaded

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

4,845

on trigger

The instruction body, read only when the skill fires.

2.5%

of a 200k window

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

050k100k150k200k context window

4.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

1 file, 19.7 kB on disk. A bundle is text throughout: the instructions the model reads, plus the templates it fills in.

SKILL.md19.7 kB

What is not in it

No dependencies and nothing executable: a skill is text the agent reads, so the bundle is 1 file 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.

$19 once

Flowglad Setup · MIT · flowglad

one-time

Price$19 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 release of 1.x 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

Version1.0.0

Publishedno release date on file

Price$19

Referenceflowglad/flowglad-setup

Versions

v1.0.0 is what is on the shelf; no release here carries a date. Instructions change more often than APIs do — a skill can be rewritten entirely without anything it depends on moving.

v1.0.0

No earlier releases have been published to the marketplace.

Pinning

Put flowglad/flowglad-setup@1.0.0 in the install command to hold this exact version. Without the suffix you get whatever is current the day you install, and nothing moves under you afterwards.

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

flowglad

Publishes on mcprush.

0 servers listed1 skill listednot claimed

Profile

Publisher

Servers0