settlekit/plan.md
caelum0x 4afda54455 feat: monorepo scaffold + @settlekit/common contract package
- pnpm workspace, shared tsconfig, vitest
- common: ids, money (USDC base-unit math), Result/SettleKitError, time
- domain types: product, customer, payment, entitlement, delivery, integration
- 13 passing contract tests
2026-06-15 02:55:22 +03:00

1915 lines
32 KiB
Markdown
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

Yes. The product becomes much stronger if it is **not only “crypto checkout”**, but a full **developer revenue operating system**.
The key idea:
> People should use this because it does the annoying work after payment: GitHub access, SaaS seats, API keys, license keys, subscriptions, file delivery, usage billing, customer portal, webhooks, and agent payments.
Payments alone are not enough. **Access automation is the product.**
I will expand the product as **SettleKit Commerce OS**.
---
# 1. New product positioning
## Old idea
```text
USDC checkout for Arc
```
Good, but too small.
## Better product
```text
SettleKit is the commerce OS for developers selling software, private repos,
SaaS, APIs, AI tools, datasets, templates, licenses, and agent services in USDC.
```
## Strong one-liner
> **Sell anything a developer can build: private GitHub repos, SaaS plans, APIs, AI tools, datasets, templates, licenses, Discord access, and agent services — with USDC checkout, automatic access delivery, and Arc/Circle payments.**
## What people actually need
Developers do not only need payment. They need:
```text
Payment → access → usage tracking → renewal → revocation → support → analytics
```
SettleKit should own that full flow.
---
# 2. Product should support these sale types
SettleKit should let sellers create these product types:
```ts
type ProductType =
| "saas_plan"
| "github_repo_access"
| "github_org_team_access"
| "api_access"
| "paid_api_call"
| "ai_agent_service"
| "digital_download"
| "code_template"
| "dataset"
| "license_key"
| "private_package"
| "discord_access"
| "support_plan"
| "course_or_content"
| "consulting_slot"
| "escrow_task";
```
This makes the platform feel necessary.
A developer should open SettleKit and think:
> “I can monetize my whole developer business here.”
---
# 3. Main product expansion
## Product 1 — GitHub repo sales
This is one of the strongest features.
### What sellers can sell
```text
- Private GitHub repo access
- Premium open-source repo access
- Paid starter templates
- Paid boilerplates
- Private SDKs
- Private AI agent code
- Private trading bots
- Private SaaS templates
- Private automation scripts
- Private course/project repositories
- Premium examples for open-source projects
```
### Seller flow
```text
1. Seller connects GitHub
2. Seller installs SettleKit GitHub App
3. Seller selects repo or organization team
4. Seller creates price:
- one-time
- monthly
- yearly
- lifetime
5. SettleKit creates hosted checkout page
6. Buyer pays in USDC
7. Buyer enters GitHub username
8. SettleKit invites buyer to repo/team
9. Buyer gets access page + receipt
10. If subscription expires, SettleKit removes access
```
### Buyer flow
```text
1. Open checkout link
2. Pay 25 USDC
3. Enter GitHub username
4. Accept GitHub invite
5. Access private repo
6. Receive updates while subscription is active
```
### Important honesty
For private repos, you can revoke **future access and updates**, but you cannot stop someone from using code they already cloned. So position it as:
```text
Paid access to private repo, updates, issues, releases, support, license key,
and community — not perfect DRM.
```
### Features needed
```text
- GitHub App install
- Repo selector
- Team selector
- Buyer GitHub username collection
- Invite buyer to repo
- Add buyer to team
- Remove buyer on expiry/refund
- Sync access every day
- License key attached to repo purchase
- Seat limits
- Access logs
- GitHub webhook support
- Failed invite handling
```
### Why people need it
Today a developer selling a private repo usually needs:
```text
Gumroad/LemonSqueezy/Polar + manual GitHub invite + spreadsheet + email + license keys
```
SettleKit makes it:
```text
Connect GitHub → create price → share link → access is automatic
```
That is a real painkiller.
---
# 4. Product 2 — SaaS plan purchases
SettleKit should let SaaS companies sell plans with USDC.
## What sellers can sell
```text
- SaaS subscriptions
- Lifetime deals
- Team seats
- Usage-based credits
- API access plans
- Premium feature unlocks
- Pro dashboard access
- White-label plans
```
## Seller flow
```text
1. Seller creates SaaS product
2. Seller creates plans:
- Free
- Pro
- Team
- Business
3. Seller defines entitlements:
- max_projects = 10
- max_api_calls = 100000
- feature_ai_export = true
- team_seats = 5
4. Seller installs SDK in their SaaS app
5. Buyer pays in USDC
6. Seller app checks entitlement through SettleKit
7. Buyer gets access instantly
```
## SaaS SDK example
```ts
import { settlekit } from "@settlekit/sdk";
const entitlement = await settlekit.entitlements.verify({
customerId: user.id,
feature: "ai_export",
});
if (!entitlement.allowed) {
throw new Error("Upgrade required");
}
```
## React paywall component
```tsx
import { Paywall } from "@settlekit/react";
export function ExportButton() {
return (
<Paywall feature="ai_export" fallback={<UpgradeButton />}>
<button>Export with AI</button>
</Paywall>
);
}
```
## SaaS features
```text
- Plan creation
- Seat management
- Organization billing
- Team invites
- Feature flags
- Entitlements
- Usage limits
- Renewal reminders
- Grace periods
- Upgrade/downgrade
- Customer portal
- Webhook events
```
## Why people need it
Crypto-native SaaS founders do not want to build billing, entitlement logic, license checks, renewal pages, and payment verification themselves.
SettleKit gives them:
```text
USDC checkout + subscription logic + access control + SDK
```
---
# 5. Product 3 — Paid APIs and x402 agent payments
This is your most unique Circle/Arc feature.
## What sellers can sell
```text
- Paid API calls
- AI model calls
- Dataset queries
- Web search API calls
- Code review API calls
- Market data
- Onchain analytics
- Image generation calls
- Agent tools
- Scraping endpoints
- Research endpoints
```
## Developer flow
```text
1. Developer creates paid API product
2. Developer sets price:
- 0.001 USDC per call
- 0.01 USDC per request
- 5 USDC per 10,000 credits
3. Developer wraps API route with SettleKit middleware
4. Human or AI agent calls endpoint
5. Endpoint returns HTTP 402 Payment Required
6. Buyer/agent pays
7. Endpoint returns response
8. Usage and revenue show in dashboard
```
## SDK example
```ts
import { withSettleKitPayment } from "@settlekit/x402";
export const GET = withSettleKitPayment({
price: "0.005",
currency: "USDC",
productId: "prod_research_api",
})(async function handler(req) {
return Response.json({
answer: "Paid research result",
});
});
```
## Why people need it
API businesses usually force buyers into:
```text
monthly subscription + API key + prepaid plan
```
But AI agents need:
```text
discover endpoint → pay small amount → get result
```
SettleKit should make paid APIs as easy as adding middleware.
---
# 6. Product 4 — Digital product sales
This makes the product useful beyond SaaS.
## What sellers can sell
```text
- PDF guides
- Courses
- Code templates
- Figma files
- Notion templates
- AI prompt packs
- Dataset files
- CSV exports
- Research reports
- Plugin downloads
- Boilerplate ZIPs
```
## Features
```text
- Upload file
- Create product page
- Set price in USDC
- Buyer pays
- Buyer gets signed download link
- Download expires
- Download count limit
- Receipt
- Customer portal
- Refund request
```
## Delivery rules
```text
- Expire link after 24 hours
- Limit to 5 downloads
- Allow merchant to regenerate link
- Revoke access after refund
```
## Why people need it
This competes with Gumroad-style flows, but with USDC and developer-native delivery.
---
# 7. Product 5 — License key system
License keys are essential for software sellers.
## What sellers can sell
```text
- Desktop apps
- CLI tools
- SaaS add-ons
- WordPress/plugins
- VS Code extensions
- AI tools
- Private SDKs
- Trading bots
- Automation software
```
## License key features
```text
- Generate license key after payment
- Validate license from app
- Machine activation limits
- Domain activation limits
- Expiration date
- Renewal date
- Revoke key
- Rotate key
- Offline validation token
- Customer portal view
```
## SDK example
```ts
const valid = await settlekit.licenseKeys.verify({
licenseKey: userLicenseKey,
productId: "prod_cli_tool",
machineId: machineFingerprint,
});
if (!valid.active) {
throw new Error("Invalid license");
}
```
## Why people need it
Developers selling paid software need license logic. Most do not want to build it.
SettleKit gives:
```text
Payment + key generation + verification API + customer portal
```
---
# 8. Product 6 — Private package access
This is another developer-specific feature.
## What sellers can sell
```text
- Private npm packages
- Private Python packages
- Private SDKs
- Paid libraries
- Internal templates
- Premium components
```
## Possible access methods
```text
- GitHub Packages access
- Private npm registry integration later
- Token-based package download
- Private release download
- Signed artifact links
```
## Buyer flow
```text
1. Buyer pays
2. Buyer receives package token/instructions
3. Buyer installs package
4. Subscription controls whether token remains valid
```
Example:
```bash
npm install @seller/premium-sdk
```
But access only works if the buyer has an active entitlement.
---
# 9. Product 7 — Discord/community access
Many developer products include community access.
## Seller flow
```text
1. Seller connects Discord
2. Seller selects server
3. Seller selects paid role
4. Buyer pays
5. Buyer connects Discord
6. SettleKit assigns role
7. Role is removed on expiry/refund
```
## What this supports
```text
- Paid support communities
- Private founder groups
- Premium AI tool communities
- Course communities
- Private alpha groups
- Developer support channels
```
This pairs well with GitHub repo sales:
```text
Buy repo → get GitHub access + Discord support + license key
```
---
# 10. Product 8 — Support plans
Developers and open-source maintainers can sell support.
## What sellers can sell
```text
- Priority support
- Private support channel
- Monthly office hours
- Bugfix retainers
- Consulting packages
- Code review packages
- Installation help
```
## Features
```text
- Support plan checkout
- Support entitlement
- Discord/GitHub issue label access
- Support SLA display
- Renewal reminders
- Customer portal
```
Example product:
```text
Premium Support for Open Source Library
Price: 99 USDC/month
Includes:
- Private Discord channel
- Priority GitHub issue response
- Monthly office hour
```
This is very useful for open-source maintainers.
---
# 11. Product 9 — Agent service marketplace
This is the future-facing part.
## What sellers list
```text
- Paid APIs
- AI tools
- Agent tools
- Research agents
- Data agents
- Code review agents
- Deployment agents
- Workflow agents
```
## Human-readable listing
```text
Name: Legal Document Parser
Price: 0.05 USDC/request
Input: PDF
Output: JSON summary
Payment: x402
Network: Arc
```
## Agent-readable listing
```json
{
"name": "Legal Document Parser",
"description": "Parses legal PDFs into structured JSON",
"price": "0.05",
"currency": "USDC",
"paymentProtocol": "x402",
"network": "arc",
"endpoint": "https://api.example.com/parse",
"inputSchema": {
"type": "object",
"properties": {
"pdfUrl": { "type": "string" }
}
}
}
```
## Why people need it
AI agents need a way to discover paid tools. Developers need a way to sell tools to agents.
SettleKit becomes:
```text
Marketplace + payment protocol + access layer
```
That is much stronger than checkout alone.
---
# 12. Product 10 — Escrow tasks for agents and freelancers
This can be a later but powerful product.
## What buyers can buy
```text
- Code review task
- Bug fix task
- Data cleaning task
- Research task
- Deployment task
- Website generation task
- AI agent job
```
## Flow
```text
1. Buyer creates task
2. Buyer funds escrow in USDC
3. Human or AI agent accepts task
4. Worker submits result
5. Buyer approves
6. Funds release
7. If rejected, refund/dispute path starts
```
This makes SettleKit not only a checkout system, but a commerce network for autonomous work.
---
# 13. Bundle products together
This is how you make people really need it.
Do not sell features separately. Let sellers create **bundles**.
## Example bundle 1 — SaaS starter kit seller
```text
Product: AI SaaS Boilerplate Pro
Price: 149 USDC one-time
Includes:
- Private GitHub repo access
- License key
- ZIP download
- Discord support role for 90 days
- Future repo updates for 1 year
```
## Example bundle 2 — paid AI API
```text
Product: Research API Pro
Price: 20 USDC prepaid credits
Includes:
- API key
- 20,000 API credits
- x402 pay-per-call support
- Usage dashboard
```
## Example bundle 3 — open-source maintainer
```text
Product: Premium Support
Price: 99 USDC/month
Includes:
- Private Discord channel
- Priority GitHub issue access
- Early release access
- 2 support tickets/month
```
## Example bundle 4 — B2B SaaS
```text
Product: Team Plan
Price: 300 USDC/month
Includes:
- 10 seats
- 1M API calls
- Premium features
- Customer portal
- Webhook integration
```
Bundles are important because they make SettleKit more than “checkout.”
---
# 14. The core engine: Universal Entitlements
This is the most important architecture idea.
Everything should become an entitlement.
```text
Payment gives entitlement.
Entitlement gives access.
Access can be GitHub, SaaS, API, file, Discord, license, package, or agent tool.
```
## Entitlement examples
```json
{
"customerId": "cus_123",
"productId": "prod_ai_saas_template",
"entitlementType": "github_repo_access",
"resourceId": "github_repo_456",
"status": "active",
"expiresAt": "2026-12-31T00:00:00Z"
}
```
```json
{
"customerId": "cus_789",
"productId": "prod_research_api",
"entitlementType": "api_credits",
"creditsRemaining": 10000,
"status": "active"
}
```
```json
{
"customerId": "cus_555",
"productId": "prod_saas_pro",
"entitlementType": "saas_feature",
"features": {
"ai_export": true,
"team_seats": 5,
"max_projects": 20
}
}
```
This one concept powers the whole product.
---
# 15. Product objects
Your system should have these main objects.
```text
Organization
User
Merchant
Customer
Product
Price
Bundle
CheckoutSession
Payment
Subscription
UsageMeter
CreditBalance
Entitlement
DeliveryAction
LicenseKey
ApiKey
GitHubInstallation
GitHubRepoAccess
DiscordRoleAccess
FileAsset
WebhookEndpoint
MarketplaceListing
AgentService
EscrowTask
PayoutWallet
RiskProfile
```
## Product
```ts
type Product = {
id: string;
merchantId: string;
name: string;
description: string;
type: ProductType;
status: "draft" | "active" | "archived";
deliveryMode: DeliveryMode;
};
```
## Price
```ts
type Price = {
id: string;
productId: string;
amount: string;
currency: "USDC";
interval?: "one_time" | "monthly" | "yearly";
usageBased?: boolean;
};
```
## Delivery action
```ts
type DeliveryAction =
| { type: "github_invite"; repoId: string }
| { type: "github_team_add"; teamId: string }
| { type: "license_key_create"; policyId: string }
| { type: "api_key_create"; scopes: string[] }
| { type: "file_access_grant"; fileId: string }
| { type: "discord_role_add"; roleId: string }
| { type: "saas_entitlement_create"; features: Record<string, unknown> }
| { type: "webhook_send"; url: string };
```
This lets one purchase trigger multiple actions.
---
# 16. New dashboard sections
Your merchant dashboard should expand to this:
```text
Dashboard
Products
Bundles
Checkout Links
Payments
Customers
Subscriptions
Usage Billing
Entitlements
License Keys
API Keys
Files
GitHub Access
Discord Access
SaaS Plans
Paid APIs
Agent Services
Marketplace
Webhooks
Payouts
Analytics
Settings
```
## Important page: Product builder
The product builder should ask:
```text
What are you selling?
[ ] SaaS plan
[ ] Private GitHub repo
[ ] API access
[ ] Paid API call
[ ] Digital download
[ ] License key
[ ] Discord/community access
[ ] AI agent service
[ ] Dataset
[ ] Bundle
```
Then it should ask:
```text
How should access be delivered?
[ ] Invite to GitHub repo
[ ] Add to GitHub team
[ ] Issue license key
[ ] Issue API key
[ ] Grant SaaS entitlement
[ ] Send webhook
[ ] Assign Discord role
[ ] Unlock file download
```
This is what makes the product feel powerful.
---
# 17. Folder expansion for this full product
Add these new packages and apps to the previous architecture.
```text
settlekit/
apps/
dashboard/
checkout/
api/
worker/
docs/
marketplace/
admin/
examples/
packages/
github/
discord/
saas/
delivery/
bundles/
entitlements/
license-keys/
api-keys/
file-delivery/
usage/
marketplace-core/
agent-services/
escrow/
payments/
arc/
circle/
x402/
webhooks/
risk/
notifications/
database/
common/
```
---
# 18. New package: `packages/github`
```text
packages/github/
src/
github-app-client.ts
github-oauth.ts
github-installations.ts
github-repositories.ts
github-teams.ts
github-invites.ts
github-access-granter.ts
github-access-revoker.ts
github-access-sync.ts
github-webhooks.ts
github-username-verification.ts
github-errors.ts
types.ts
test/
github-access-granter.test.ts
github-access-revoker.test.ts
github-access-sync.test.ts
package.json
```
## Responsibilities
```text
- Connect seller GitHub account/org
- Install GitHub App
- Fetch seller repos
- Fetch org teams
- Invite buyer to repo
- Add buyer to team
- Remove buyer after expiry
- Sync access status
- Handle failed invites
```
---
# 19. New package: `packages/discord`
```text
packages/discord/
src/
discord-client.ts
discord-oauth.ts
discord-guilds.ts
discord-roles.ts
discord-role-granter.ts
discord-role-revoker.ts
discord-access-sync.ts
discord-errors.ts
types.ts
test/
discord-role-granter.test.ts
discord-role-revoker.test.ts
package.json
```
## Responsibilities
```text
- Connect Discord server
- Select paid role
- Ask buyer to connect Discord
- Add role after payment
- Remove role on expiry/refund
```
---
# 20. New package: `packages/saas`
```text
packages/saas/
src/
saas-plan.ts
feature-flags.ts
seat-limits.ts
tenant-entitlements.ts
org-billing.ts
usage-limits.ts
customer-portal.ts
upgrade-downgrade.ts
grace-periods.ts
saas-webhooks.ts
types.ts
test/
feature-flags.test.ts
seat-limits.test.ts
tenant-entitlements.test.ts
package.json
```
## Responsibilities
```text
- SaaS plan definitions
- Feature entitlements
- Seat entitlements
- Usage limits
- Upgrade/downgrade logic
- Renewal/grace period logic
```
---
# 21. New package: `packages/delivery`
This is the action engine that runs after payment.
```text
packages/delivery/
src/
delivery-action.ts
delivery-plan.ts
delivery-runner.ts
delivery-status.ts
delivery-retry.ts
delivery-rollback.ts
delivery-logs.ts
actions/
grant-github-repo.ts
grant-github-team.ts
issue-license-key.ts
issue-api-key.ts
grant-file-access.ts
grant-discord-role.ts
create-saas-entitlement.ts
send-webhook.ts
send-email.ts
types.ts
errors.ts
test/
delivery-runner.test.ts
delivery-retry.test.ts
grant-github-repo.test.ts
package.json
```
## Why this matters
This package makes SettleKit powerful.
A purchase can trigger:
```text
payment.succeeded
→ grant GitHub access
→ issue license key
→ assign Discord role
→ create SaaS entitlement
→ send webhook
→ email buyer
```
---
# 22. New package: `packages/bundles`
```text
packages/bundles/
src/
bundle.ts
bundle-items.ts
bundle-pricing.ts
bundle-delivery-plan.ts
bundle-entitlements.ts
types.ts
test/
bundle-delivery-plan.test.ts
package.json
```
## Responsibilities
```text
- Create bundle products
- Attach many products to one checkout
- Generate many entitlements from one payment
```
Example:
```text
AI SaaS Template Bundle
- GitHub repo access
- License key
- Discord role
- File download
- 1 year of updates
```
---
# 23. New package: `packages/agent-services`
```text
packages/agent-services/
src/
agent-service.ts
agent-service-metadata.ts
agent-readable-schema.ts
agent-pricing.ts
agent-usage.ts
agent-discovery.ts
agent-reputation.ts
agent-payment-policy.ts
types.ts
test/
agent-service-metadata.test.ts
agent-pricing.test.ts
package.json
```
## Responsibilities
```text
- Let sellers list paid agent services
- Generate machine-readable metadata
- Connect agent service to x402 payment
- Track agent buyers and usage
```
---
# 24. New package: `packages/escrow`
```text
packages/escrow/
src/
escrow-task.ts
escrow-status.ts
escrow-funding.ts
escrow-release.ts
escrow-refund.ts
escrow-disputes.ts
task-submissions.ts
task-review.ts
types.ts
test/
escrow-release.test.ts
escrow-refund.test.ts
package.json
```
## Responsibilities
```text
- Fund task
- Assign worker/agent
- Submit work
- Approve work
- Release payment
- Refund if failed
```
This should be later, but it can become a big product.
---
# 25. Database additions
Add these tables.
```text
github_installations
github_repositories
github_teams
github_repo_access_grants
github_access_sync_runs
discord_connections
discord_guilds
discord_roles
discord_role_grants
saas_plans
saas_features
saas_seats
saas_entitlement_rules
bundles
bundle_items
delivery_plans
delivery_actions
delivery_runs
delivery_logs
agent_services
agent_service_metadata
agent_buyers
agent_usage_events
escrow_tasks
escrow_fundings
escrow_submissions
escrow_releases
escrow_disputes
```
---
# 26. API endpoints to add
## GitHub
```text
POST /v1/integrations/github/installations
GET /v1/integrations/github/installations
GET /v1/integrations/github/repositories
GET /v1/integrations/github/teams
POST /v1/github/access/grant
POST /v1/github/access/revoke
POST /v1/github/access/sync
```
## Discord
```text
POST /v1/integrations/discord/connect
GET /v1/integrations/discord/guilds
GET /v1/integrations/discord/roles
POST /v1/discord/access/grant
POST /v1/discord/access/revoke
```
## SaaS
```text
POST /v1/saas/plans
GET /v1/saas/plans
POST /v1/saas/features
POST /v1/saas/entitlements/verify
POST /v1/saas/seats
POST /v1/saas/seats/remove
```
## Bundles
```text
POST /v1/bundles
GET /v1/bundles
GET /v1/bundles/:id
PATCH /v1/bundles/:id
POST /v1/bundles/:id/publish
```
## Delivery
```text
GET /v1/delivery-runs
GET /v1/delivery-runs/:id
POST /v1/delivery-runs/:id/retry
POST /v1/delivery-actions/test
```
## Agent services
```text
POST /v1/agent-services
GET /v1/agent-services
GET /v1/agent-services/:id
PATCH /v1/agent-services/:id
POST /v1/agent-services/:id/publish
GET /v1/agent-services/:id/metadata.json
```
## Escrow
```text
POST /v1/escrow/tasks
GET /v1/escrow/tasks
POST /v1/escrow/tasks/:id/fund
POST /v1/escrow/tasks/:id/submit
POST /v1/escrow/tasks/:id/approve
POST /v1/escrow/tasks/:id/refund
```
---
# 27. New dashboard pages
Add these to `apps/dashboard`.
```text
apps/dashboard/app/org/[orgSlug]/
github/
page.tsx
install/
page.tsx
repositories/
page.tsx
teams/
page.tsx
access/
page.tsx
discord/
page.tsx
servers/
page.tsx
roles/
page.tsx
access/
page.tsx
saas/
plans/
page.tsx
features/
page.tsx
seats/
page.tsx
entitlements/
page.tsx
bundles/
page.tsx
new/
page.tsx
[bundleId]/
page.tsx
delivery/
runs/
page.tsx
logs/
page.tsx
agent-services/
page.tsx
new/
page.tsx
[serviceId]/
page.tsx
escrow/
tasks/
page.tsx
[taskId]/
page.tsx
```
---
# 28. Product builder UX
The dashboard should have one main button:
```text
+ Create Product
```
Then show:
```text
What do you want to sell?
1. SaaS plan
2. Private GitHub repo
3. Private GitHub organization/team
4. API access
5. Paid API call
6. AI agent service
7. Digital download
8. Code template
9. License key
10. Discord/community access
11. Support plan
12. Bundle
```
Then:
```text
How do you want to charge?
1. One-time payment
2. Monthly subscription
3. Yearly subscription
4. Prepaid credits
5. Pay per API call
6. Custom quote
```
Then:
```text
What should happen after payment?
1. Invite buyer to GitHub repo
2. Add buyer to GitHub team
3. Issue license key
4. Issue API key
5. Grant SaaS feature access
6. Unlock file download
7. Assign Discord role
8. Send webhook to my app
9. Send email instructions
```
This UX makes the product easy to understand.
---
# 29. Make people need it: killer use cases
## Use case 1 — “Sell my private repo in 5 minutes”
Target:
```text
Indie hackers, template sellers, AI boilerplate sellers, open-source maintainers
```
Promise:
```text
Connect GitHub. Pick repo. Set price. Share link. We handle access.
```
This is probably your best first viral wedge.
---
## Use case 2 — “Add USDC billing to my SaaS without building billing”
Target:
```text
Crypto SaaS, Web3 SaaS, AI SaaS, B2B tools
```
Promise:
```text
Create plans, check entitlements, sell subscriptions, manage seats.
```
---
## Use case 3 — “Monetize my API with one middleware”
Target:
```text
API developers, data companies, AI tool builders
```
Promise:
```text
Wrap your endpoint. Agents and humans pay per call.
```
---
## Use case 4 — “Sell a complete developer bundle”
Target:
```text
Course creators, template sellers, developer educators
```
Promise:
```text
One checkout can deliver GitHub repo + ZIP + license key + Discord role.
```
---
## Use case 5 — “Let AI agents buy my service”
Target:
```text
Future-facing AI infra builders
```
Promise:
```text
Make your API discoverable and payable by autonomous agents.
```
---
# 30. What makes this different from Polar, Creem, Gumroad, Stripe, Paddle
Do not compete only as “another checkout.”
Your differentiation:
```text
1. Arc-native USDC payments
2. Circle Gateway/x402 agent payments
3. GitHub repo access automation
4. Developer-specific entitlements
5. SaaS feature gating SDK
6. Paid API middleware
7. License/API key server
8. Bundle delivery engine
9. Marketplace for humans and agents
10. Open-source core
```
## Positioning table
| User pain | Existing workaround | SettleKit solution |
| -------------------- | ------------------------------- | ----------------------------------- |
| Sell private repo | Payment tool + manual invite | Pay → automatic GitHub access |
| Sell SaaS | Build billing system | Plans + entitlements SDK |
| Sell API | API key + Stripe/custom billing | Paid API middleware + x402 |
| Sell template | Gumroad + manual support | Checkout + GitHub + files + license |
| Sell support | Discord manual roles | Pay → Discord role + renewal |
| Sell to AI agents | Not easy | x402 + USDC per request |
| Manage access expiry | Manual spreadsheet | Automatic entitlement revocation |
---
# 31. The “must-use” features
These are the features that make people stick.
## 1. Universal access automation
```text
Payment automatically grants access.
Refund/expiry automatically removes access.
```
## 2. Bundle delivery
```text
One payment can deliver multiple things.
```
Example:
```text
GitHub repo + license key + Discord role + file download + API credits
```
## 3. Customer portal
Buyers can manage everything:
```text
- Receipts
- License keys
- API keys
- Downloads
- GitHub access
- Discord access
- Subscriptions
- Usage credits
```
## 4. Merchant dashboard
Sellers can see:
```text
- Revenue
- Customers
- Active access
- Expiring subscriptions
- Failed delivery actions
- API usage
- GitHub access status
```
## 5. Entitlement API
SaaS apps can depend on SettleKit:
```text
Can this user access feature X?
How many seats do they have?
How many credits remain?
```
Once sellers integrate entitlements, SettleKit becomes core infrastructure.
## 6. Paid API middleware
Developers do not need to understand complex payment flows.
```text
withPayment({ price: "0.01 USDC" })(handler)
```
## 7. Marketplace
Sellers get discovery, not only infrastructure.
That makes the product more valuable.
---
# 32. Pricing strategy for this expanded product
## Free
```text
$0/month
3 products
1 GitHub repo product
basic checkout
community support
1% transaction fee
```
## Creator
```text
$19/month
20 products
GitHub repo sales
digital downloads
license keys
Discord access
0.75% transaction fee
```
## Pro
```text
$49/month
SaaS plans
API keys
subscriptions
webhooks
bundles
customer portal
0.5% transaction fee
```
## Business
```text
$199/month
team seats
usage billing
paid APIs
x402 payments
advanced analytics
webhook replay
0.25% transaction fee
```
## Enterprise
```text
Custom
private deployment
custom compliance
custom integrations
SLA
dedicated support
```
## Marketplace fee
```text
5%–15% on marketplace-discovered sales
```
---
# 33. Full expanded product roadmap
## Phase 1 — Core commerce
```text
- Products
- Prices
- Checkout
- USDC payments
- Customer portal
- Entitlements
- Webhooks
- Merchant dashboard
```
## Phase 2 — GitHub and digital sellers
```text
- GitHub App
- Private repo sales
- GitHub team access
- License keys
- File downloads
- Bundles
- Discord access
```
This is the best adoption phase.
## Phase 3 — SaaS billing
```text
- SaaS plans
- Feature entitlements
- Seat management
- Usage limits
- SDK checks
- Upgrade/downgrade
- Renewal flows
```
## Phase 4 — Paid APIs and agent payments
```text
- API keys
- Usage metering
- x402 middleware
- Circle Gateway nanopayments
- Agent buyer records
- Paid API dashboard
```
## Phase 5 — Marketplace
```text
- Public seller profiles
- Product listings
- Paid API listings
- Agent-readable metadata
- Ratings/reviews
- Marketplace fee
```
## Phase 6 — Enterprise and escrow
```text
- Escrow tasks
- B2B invoices
- Treasury wallet approvals
- KYB integrations
- Compliance/risk dashboards
- Private deployments
```
---
# 34. Strong landing page message
Use this kind of copy:
```text
Sell your software in USDC.
SettleKit lets developers sell private GitHub repos, SaaS subscriptions,
API access, AI tools, templates, datasets, license keys, and digital downloads.
Connect GitHub, create a product, set a USDC price, and share your checkout link.
We handle payment verification, access delivery, subscriptions, license keys,
webhooks, and customer portals.
```
## Landing page sections
```text
Hero:
Sell software, APIs, and private repos in USDC
Use cases:
Private GitHub repos
SaaS plans
Paid APIs
AI agent services
Digital downloads
License keys
Discord communities
How it works:
Create product → Set price → Buyer pays → Access delivered
Developer tools:
SDKs, webhooks, entitlements, x402 middleware
Marketplace:
Get discovered by humans and AI agents
Open source:
Self-host or use hosted cloud
```
---
# 35. Final expanded product definition
SettleKit should become:
```text
SettleKit Commerce OS
1. USDC checkout
2. Arc settlement
3. Circle Gateway/x402 payments
4. GitHub repo sales
5. GitHub team access
6. SaaS plan billing
7. Feature entitlement SDK
8. API key issuance
9. License key issuance
10. Digital downloads
11. Discord role access
12. Paid API middleware
13. AI agent service payments
14. Usage billing
15. Prepaid credits
16. Bundles
17. Customer portal
18. Merchant dashboard
19. Marketplace
20. Admin/risk tools
```
The simplest powerful pitch:
> **“SettleKit lets developers sell private repos, SaaS, APIs, templates, and AI tools in USDC — and automatically delivers access after payment.”**
That is the product people need.