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

32 KiB
Raw Permalink Blame History

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.