- 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
32 KiB
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
USDC checkout for Arc
Good, but too small.
Better product
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:
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:
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
- 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
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
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:
Paid access to private repo, updates, issues, releases, support, license key,
and community — not perfect DRM.
Features needed
- 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:
Gumroad/LemonSqueezy/Polar + manual GitHub invite + spreadsheet + email + license keys
SettleKit makes it:
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
- SaaS subscriptions
- Lifetime deals
- Team seats
- Usage-based credits
- API access plans
- Premium feature unlocks
- Pro dashboard access
- White-label plans
Seller flow
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
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
import { Paywall } from "@settlekit/react";
export function ExportButton() {
return (
<Paywall feature="ai_export" fallback={<UpgradeButton />}>
<button>Export with AI</button>
</Paywall>
);
}
SaaS features
- 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:
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
- 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
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
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:
monthly subscription + API key + prepaid plan
But AI agents need:
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
- PDF guides
- Courses
- Code templates
- Figma files
- Notion templates
- AI prompt packs
- Dataset files
- CSV exports
- Research reports
- Plugin downloads
- Boilerplate ZIPs
Features
- 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
- 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
- Desktop apps
- CLI tools
- SaaS add-ons
- WordPress/plugins
- VS Code extensions
- AI tools
- Private SDKs
- Trading bots
- Automation software
License key features
- 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
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:
Payment + key generation + verification API + customer portal
8. Product 6 — Private package access
This is another developer-specific feature.
What sellers can sell
- Private npm packages
- Private Python packages
- Private SDKs
- Paid libraries
- Internal templates
- Premium components
Possible access methods
- GitHub Packages access
- Private npm registry integration later
- Token-based package download
- Private release download
- Signed artifact links
Buyer flow
1. Buyer pays
2. Buyer receives package token/instructions
3. Buyer installs package
4. Subscription controls whether token remains valid
Example:
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
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
- 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:
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
- Priority support
- Private support channel
- Monthly office hours
- Bugfix retainers
- Consulting packages
- Code review packages
- Installation help
Features
- Support plan checkout
- Support entitlement
- Discord/GitHub issue label access
- Support SLA display
- Renewal reminders
- Customer portal
Example product:
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
- Paid APIs
- AI tools
- Agent tools
- Research agents
- Data agents
- Code review agents
- Deployment agents
- Workflow agents
Human-readable listing
Name: Legal Document Parser
Price: 0.05 USDC/request
Input: PDF
Output: JSON summary
Payment: x402
Network: Arc
Agent-readable listing
{
"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:
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
- Code review task
- Bug fix task
- Data cleaning task
- Research task
- Deployment task
- Website generation task
- AI agent job
Flow
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
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
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
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
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.
Payment gives entitlement.
Entitlement gives access.
Access can be GitHub, SaaS, API, file, Discord, license, package, or agent tool.
Entitlement examples
{
"customerId": "cus_123",
"productId": "prod_ai_saas_template",
"entitlementType": "github_repo_access",
"resourceId": "github_repo_456",
"status": "active",
"expiresAt": "2026-12-31T00:00:00Z"
}
{
"customerId": "cus_789",
"productId": "prod_research_api",
"entitlementType": "api_credits",
"creditsRemaining": 10000,
"status": "active"
}
{
"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.
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
type Product = {
id: string;
merchantId: string;
name: string;
description: string;
type: ProductType;
status: "draft" | "active" | "archived";
deliveryMode: DeliveryMode;
};
Price
type Price = {
id: string;
productId: string;
amount: string;
currency: "USDC";
interval?: "one_time" | "monthly" | "yearly";
usageBased?: boolean;
};
Delivery action
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:
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:
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:
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.
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
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
- 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
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
- 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
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
- 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.
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:
payment.succeeded
→ grant GitHub access
→ issue license key
→ assign Discord role
→ create SaaS entitlement
→ send webhook
→ email buyer
22. New package: packages/bundles
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
- Create bundle products
- Attach many products to one checkout
- Generate many entitlements from one payment
Example:
AI SaaS Template Bundle
- GitHub repo access
- License key
- Discord role
- File download
- 1 year of updates
23. New package: packages/agent-services
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
- 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
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
- 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.
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
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
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
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
POST /v1/bundles
GET /v1/bundles
GET /v1/bundles/:id
PATCH /v1/bundles/:id
POST /v1/bundles/:id/publish
Delivery
GET /v1/delivery-runs
GET /v1/delivery-runs/:id
POST /v1/delivery-runs/:id/retry
POST /v1/delivery-actions/test
Agent services
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
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.
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:
+ Create Product
Then show:
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:
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:
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:
Indie hackers, template sellers, AI boilerplate sellers, open-source maintainers
Promise:
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:
Crypto SaaS, Web3 SaaS, AI SaaS, B2B tools
Promise:
Create plans, check entitlements, sell subscriptions, manage seats.
Use case 3 — “Monetize my API with one middleware”
Target:
API developers, data companies, AI tool builders
Promise:
Wrap your endpoint. Agents and humans pay per call.
Use case 4 — “Sell a complete developer bundle”
Target:
Course creators, template sellers, developer educators
Promise:
One checkout can deliver GitHub repo + ZIP + license key + Discord role.
Use case 5 — “Let AI agents buy my service”
Target:
Future-facing AI infra builders
Promise:
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:
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
Payment automatically grants access.
Refund/expiry automatically removes access.
2. Bundle delivery
One payment can deliver multiple things.
Example:
GitHub repo + license key + Discord role + file download + API credits
3. Customer portal
Buyers can manage everything:
- Receipts
- License keys
- API keys
- Downloads
- GitHub access
- Discord access
- Subscriptions
- Usage credits
4. Merchant dashboard
Sellers can see:
- Revenue
- Customers
- Active access
- Expiring subscriptions
- Failed delivery actions
- API usage
- GitHub access status
5. Entitlement API
SaaS apps can depend on SettleKit:
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.
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
$0/month
3 products
1 GitHub repo product
basic checkout
community support
1% transaction fee
Creator
$19/month
20 products
GitHub repo sales
digital downloads
license keys
Discord access
0.75% transaction fee
Pro
$49/month
SaaS plans
API keys
subscriptions
webhooks
bundles
customer portal
0.5% transaction fee
Business
$199/month
team seats
usage billing
paid APIs
x402 payments
advanced analytics
webhook replay
0.25% transaction fee
Enterprise
Custom
private deployment
custom compliance
custom integrations
SLA
dedicated support
Marketplace fee
5%–15% on marketplace-discovered sales
33. Full expanded product roadmap
Phase 1 — Core commerce
- Products
- Prices
- Checkout
- USDC payments
- Customer portal
- Entitlements
- Webhooks
- Merchant dashboard
Phase 2 — GitHub and digital sellers
- 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
- SaaS plans
- Feature entitlements
- Seat management
- Usage limits
- SDK checks
- Upgrade/downgrade
- Renewal flows
Phase 4 — Paid APIs and agent payments
- API keys
- Usage metering
- x402 middleware
- Circle Gateway nanopayments
- Agent buyer records
- Paid API dashboard
Phase 5 — Marketplace
- Public seller profiles
- Product listings
- Paid API listings
- Agent-readable metadata
- Ratings/reviews
- Marketplace fee
Phase 6 — Enterprise and escrow
- Escrow tasks
- B2B invoices
- Treasury wallet approvals
- KYB integrations
- Compliance/risk dashboards
- Private deployments
34. Strong landing page message
Use this kind of copy:
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
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:
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.