# Build your next feature with Helpful Mods and your coding agent

Helpful Mods provides 25 standalone, production-ready TypeScript and Node.js services for the features coding agents spend the most time rebuilding: payments, bookings, team seats, publishing and more. Give the source to Claude Code, Cursor, Codex or Windsurf so your agent can connect a tested implementation to your app and focus on what makes your product different.

Pay $99 USD for your first mod and $75 for each additional different mod. Each one-time purchase includes full modifiable source code, agent setup prompts, an integration guide, examples and verification tests. Your perpetual commercial license covers one application with unlimited users, with 30 days of setup support and at least 12 months of bug and security updates. There is no Helpful Mods subscription.

Start with the [mod library](https://helpfulmods.com/library.html), then select Try this mod on a product page to use its included interface before buying. Follow the guided steps, switch between customer and staff views where offered, or select Start again for a fresh sample. Demo payments, messages and connected-provider results are simulated. Samples last up to 15 minutes and require no login or purchase. Ask Mallow a question on this website to try Website Chat.

## Find the right mod and prepare a cart

Connect to the anonymous public MCP server at `https://account.helpfulmods.com/api/mcp/catalog`. Use `search_catalog`, `get_mod_details`, `get_setup_overview` and `get_compatibility_guidance` to choose the features and hosting that fit the project. This is a Streamable HTTP JSON-RPC POST endpoint, not a page to open in the browser. The storefront `/api/mcp/catalog` route redirects to this canonical account endpoint.

Use `prepare_cart_link` with ordered distinct `productIds` and an optional `appName` to give the buyer a saved selection to review. Or open the [public cart](https://helpfulmods.com/cart.html) directly. The buyer signs in, reviews the application, licenses, price and tax, then pays in Stripe Checkout.

## Buy several mods in one payment

Use Add to Cart on the library cards or product pages. The header cart keeps the selection as you browse; remove an item or empty the cart there. A new buyer's first selected mod is $99, with each additional different mod in the same cart at $75. Your account confirms eligible returning-customer pricing and the final total.

Continue to checkout to sign in, review the selected editions, source licenses, application, personal or business purpose and tax, then pay for the selected mods in one Stripe Checkout. The public cart saves the ordered product IDs and an estimate; your account creates the quote and Checkout.

The combined cart uses the normal interactive customer account. Advanced purchase authority covers one mod at a time; it cannot call the human-only cart endpoints. The customer service creates a cart quote through `POST /v1/cart-quotes` and one Checkout through `POST /v1/cart-checkout`. When that outcome is unclear, `GET /v1/carts/{ord_UUID}/checkout` reads and reconciles the original Session. Changing or reordering a selection requires a fresh quote and confirmation. A return URL is a lookup hint, not proof of payment.

## Connect your coding agent

Open [Agent access](https://account.helpfulmods.com/agent-access), then add `https://account.helpfulmods.com/api/mcp` as a remote MCP server in a client that supports Streamable HTTP and OAuth. Sign in in the browser and choose which purchased mods your agent can read. OAuth handles the connection without copying a token or completing another purchase form.

The connection requests only `mods:read`. Its tools are `list_owned_mods`, `get_mod_source`, `read_mod_resource` and `prepare_cart_link`. Source links include their checksum; setup resources remain tied to the authorized edition. Current ownership and revocation are checked on each read. Use the tool schemas discovered by your client rather than guessing argument names.

`prepare_cart_link` accepts ordered distinct `productIds` and an optional `appName`. It prepares an ordinary human cart link with the selection and an editable application-name hint. It does not create a quote, order or charge. Open that link yourself to review source licenses, purpose, tax and the final payment. Your agent can then use the source and instructions you authorize it to read.

You can inspect and revoke connections in Agent access. Revocation stops later reads; it does not undo an already completed payment or erase source you previously downloaded. The normal connection has been exercised with the installed TypeScript MCP SDK 1.32.2. Other clients need compatible remote HTTP/OAuth support; a single configuration-file format is not shared by every coding agent.

For MCP client implementers, the server publishes protected-resource metadata at `https://account.helpfulmods.com/.well-known/oauth-protected-resource/api/mcp` (challenge alias `/api/mcp/resource-metadata`) and authorization-server metadata at `https://account.helpfulmods.com/.well-known/oauth-authorization-server`. The bounded public registration endpoint is `/api/oauth/register`; the authorization-code flow uses S256 PKCE through `/api/oauth/authorize`, the signed-in `/agent-connect?request=...` approval page and `/api/oauth/token`. `/api/oauth/revoke` revokes issued access. Client metadata documents are not offered as an alternative to the supported registration flow.

## Install the purchased source

Everything your coding agent needs for setup is in the downloaded package, including prompts, an integration guide, examples, troubleshooting and tests. Give it the package and your project, and start in the package's local test mode. Your agent connects the feature to your app, configures your provider accounts and runs the built-in checks before going live. It never needs your Helpful Mods account password to read those packaged files.

Most mods use Node.js 22.13+ and PostgreSQL 17; queued workflows also need the supplied background worker. Website Chat uses Node.js 24 and a persistent SQLite disk, with your OpenAI account for live answers. Each product page lists its hosting requirements upfront. Hosting and provider usage run through your own accounts.

## Advanced manual authority

[Advanced agent access](https://account.helpfulmods.com/agent-access/advanced) supports clients or workflows that need a manually scoped authority. Use `https://account.helpfulmods.com/api/mcp/advanced` with that authority in the client's private authorization-header store. Your Helpful Mods password and browser session stay in the account; the scoped credential supplies the agent's access.

For an advanced individual-mod purchase, the owner selects the permitted products, licensed application, spending limit in USD cents, expiry and current legal terms. The payment mode determines how approval works:

- `owner_confirmed_checkout`: the budget reserves the original $99 first-mod or $75 eligible returning price before tax and before any discount. The owner reviews the full tax and total in ordinary Stripe Checkout and decides whether to Pay.
- `agent_payment`: when direct payments are available, the owner explicitly approves this mode and a spending limit that includes tax. A compatible buyer wallet must also approve the payment credential. Follow the direct-payment flow below; the normal `mods:read` connection does not gain purchase permission.

Combined carts remain the normal interactive human flow above. Direct payment requires qualified seller configuration and a compatible MPP/SPT wallet. Follow the connected server's advertised availability. If direct payment is unavailable, use ordinary human Checkout; changing a credential or retrying repeatedly will not enable it.

Website Chat uses license version 0.1.0; the other current mods use 1.0.4. Manual product scopes from different license groups remain separate. An issuance retry with the same UUID `requestId` and identical input retains the original authority and expiry; conflicting or revoked replays refuse. The signed-in owner can inspect scope/status through `GET /v1/agent-tokens` and revoke through `DELETE /v1/agent-tokens/{authorityId}`. The list does not expose raw tokens.

## Advanced individual-mod human checkout and installation

1. On the advanced MCP server, use `search_mods` with an optional `query`, then read the product's hosting and integration requirements. Confirm the intended application, customer identity and provider accounts with the owner.
2. Call `quote_purchase` with `productId`, `licensedApplication`, and `purchasePurpose` (`personal` or `business`). An optional `discountCode` may be supplied. Purpose describes the actual licensed application; email, a company name or a tax ID does not select it. For example:

   ```json
   {"productId":"funnel","licensedApplication":"The owner's actual product","purchasePurpose":"business"}
   ```

   Read the returned `quoteId`, product/source/license details, `baseAmount`, `discountAmount` and `subtotalAmount`. Tax and total can still be unknown. A quote is not permission to Pay.
3. Call `create_owner_checkout` with that `quoteId`. Retain the returned `orderId`, status and original `checkoutUrl`. Give the owner that original Stripe Checkout handoff privately. The owner reviews the application, final price and tax, then confirms Pay. There is no agent `/pay`, direct charge or MPP payment path in this flow.
4. Use `get_order` with the original `orderId` to determine the result. A browser return is not proof of payment. When Checkout creation or payment is uncertain, retain the original quote/order/Session. The authenticated REST route `POST /v1/orders/{orderId}/reconcile` checks the current result; then read `get_order` again before requesting fresh work. There is no separate MCP reconcile tool. `GET /v1/orders/{orderId}/checkout` recovers the original Checkout; it does not create a replacement Session. Do not turn a timeout into a second purchase.
5. After confirmed paid entitlement, call `get_download` with `productId`. It returns the authorized `downloadUrl`, `sha256` and `version`. Retrieve that exact edition through the supported delegated authorization, verify the archive bytes against the returned hash, and retain the license and receipt. Do not substitute the public catalog's newest version for the edition the server authorized.
6. Call `get_resource_grant` with `productId` and that exact `sourceVersion`. The grant is limited to the paid entitlement and version/archive. Use the returned resource paths and grant for that edition. Canonical resource discovery is `/v2/resources/{productId}` and archive delivery is `/v1/downloads/{productId}?version=<authorized-version>`. Respect the grant's expiry; request a new grant with still-valid authority when needed. The owner must reauthorize an expired or revoked agent authority.
7. Extract into a private working folder and read `README.md`, `setup/SKILL.md`, `setup/AGENT_HELP.md`, `setup/error-reference.json` and `docs/DEPENDENCIES.md`. The integration guide names the real interfaces and identity requirements. Begin with the supplied local checks, then connect the owner's accounts and verify the intended user path before enabling external sending, scheduling or deployment within the owner's instructions.

## Advanced individual-mod agent payment

Live direct agent payment is currently unavailable. Use `prepare_cart_link` to send the customer to the public cart, then have them sign in and complete Stripe Checkout. The instructions below apply only after the connected server enables direct wallet payment.

Use this flow only when the connected server advertises direct payment as available and the buyer's client supports [Stripe's MPP/SPT payment flow](https://docs.stripe.com/payments/machine/mpp). Seller qualification and wallet support are required; this guide does not establish either. No live wallet purchase has been verified for this integration. The owner first creates an `agent_payment` authority at [Advanced agent access](https://account.helpfulmods.com/agent-access/advanced), approving products, application, the tax-inclusive spending limit, expiry and legal terms. Keep that commerce credential in the client's private authorization store.

1. Create one checkout with authenticated `POST https://account.helpfulmods.com/v1/agent-checkouts`. Supply a UUID `requestId`, one `productId`, `licensedApplication`, `purchasePurpose` (`personal` or `business`), and `billingAddress` with `line1`, `city`, `postalCode` and `country`; `line2` and `state` are optional. Include `termsAccepted: true`, the current `termsVersion`, `privacyVersion` and selected mod's `licenseVersion`. `discountCode` is optional. Use the actual billing address and current server-provided legal versions; do not send them to the public catalog.
2. Retain the returned stable `checkoutId` (`ac_UUID`), `quoteId`, `baseAmount`, `discountAmount`, `taxAmount`, `totalAmount`, `currency`, expiry and `paymentUrl`. Creation can return `status: calculating` with `taxAmount` and `totalAmount` set to `null`. Wait at least 30 seconds and honor any longer numeric `Retry-After` value, then repeat the original POST with the same UUID and identical input to finish the tax calculation. There is no background worker to finish it; GET reads saved state and does not start the calculation. Continue to wallet payment only when the checkout is `ready` and has a firm, non-null tax and total. Review that total before asking the wallet to spend. The authority's remaining budget must cover the total including tax. A checkout or quote does not establish payment or source access.
3. Once the checkout is ready, request the returned `paymentUrl` with `GET` or `POST`. This is the bound `https://account.helpfulmods.com/v1/agent-checkouts/{checkoutId}/pay` endpoint. Keep the commerce credential in `X-HelpfulMods-Authorization: Bearer <commerce_token>`. An HTTP `402` response provides the MPP challenge. The buyer's compatible wallet obtains an approved Shared Payment Token (SPT); retry the same payment URL with the wallet's `Authorization: Payment ...` credential and the separate commerce authorization header. Never put either credential in a URL, public prompt or source file. Preparing a checkout or returning a payment link does not itself charge the buyer.
4. Retain the payment receipt and read authenticated `GET https://account.helpfulmods.com/v1/agent-checkouts/{checkoutId}` for saved payment and order state. If checkout creation is uncertain, retry the original UUID and identical input. If payment is uncertain, read the original checkout before doing more work. Do not create a new UUID or replacement checkout to recover a timeout. Fulfillment requires verified payment; use the authorized edition, receipt, source download and setup resources as in the installation steps above.

While payment is unresolved, wait at least 30 seconds before another status check or payment retry, and honor any longer numeric `Retry-After` value in seconds. Keep the original checkout; do not poll in a tight loop or create a replacement. When no payment is pending, do not run background status polling.

Advanced MCP clients can use `create_agent_checkout` with the same strict inputs as the REST creation request and `get_agent_checkout` with `checkoutId` to read and reconcile the saved checkout. If tax is still calculating, follow the wait in step 2 and repeat `create_agent_checkout` with identical inputs; `get_agent_checkout` does not calculate tax. These tools require the same explicit `agent_payment` authority and qualification. They return the bound wallet `paymentUrl` and checkout state; neither tool charges the buyer. Discover the connected server's current schemas and availability before calling them. Normal OAuth `mods:read` remains read-only.

The server can refuse direct payment with `503 agent_payments_not_qualified` while seller setup is unqualified. Use ordinary human Checkout when direct payment or the buyer's wallet is unavailable. An existing agent-payment checkout must be resolved before starting another purchase.

## Come back for help

Use the packaged troubleshooting and matching error reference first. For an uncertain checkout or provider result, keep the original order, operation and receipt identifiers and follow its recovery route before starting new work.

If a hosted reference returns 401/403 or a sign-in page, keep working from the matching files inside the package. Renew account authorization through the supported Agent access flow when needed. For setup help, email support@helpfulmods.com with a description of the issue and leave out API keys or customer data.

[Installation walkthrough](https://helpfulmods.com/blog/install-a-mod-with-your-coding-agent/) · [Support](https://helpfulmods.com/legal/support.html) · [Source license](https://helpfulmods.com/legal/source-license.html)