KEYCARD: Holder-only access for Solana

Overview

Your wallet is the key.

Keycard lets creators, projects, games, DAOs, trading groups, and apps upload protected media, choose a Solana access rule, then share a hosted link, embed, or API gate. Viewers connect Phantom, Backpack, or Solflare, sign once, and Keycard verifies access before opening the content.

Upload

Add a file, image, video, folder, link, route, or app resource to protect.

Gate

Paste a mint, collection, NFT rule, or wallet list.

Verify

Viewers connect Phantom, Backpack, or Solflare and sign once. Keycard checks access server-side.

Open

Passing wallets receive a short-lived session for the private resource.

Positioning

Clerk/Auth0 for Solana access.

Instead of email and passwords, the credential is wallet ownership, token balance, NFT ownership, collection membership, or wallet allowlist status.

Current MVP

Hosted file gates are live.

SPL gates, NFT collection gates, wallet allowlists, encrypted uploads, direct Blob upload, and hosted unlock pages are live.

Vault

Wallet-gated media vault.

Hosted drops, rooms, links, and screens for creators, teams, DAOs, games, trading groups, and projects.

Gate

Verification layer for apps.

A reusable Solana access layer so developers stop rebuilding token-gating logic.

Access

Get the missing credential.

When a wallet fails, Keycard should guide the user to the token, NFT, or wallet path they need.

KEYCARD Vault

Wallet-gated storage for Solana media.

Vault is the creator and project product: upload drops, rooms, links, and screens, then gate access by wallet ownership. The current hosted flow starts with one encrypted file per gate; folders, rooms, screens, and video are roadmap items.

Drops

Private media drops.

Token-gated images, videos, music, PDFs, ZIP packs, and launch assets.

Rooms

Holder-only rooms.

Private file spaces for communities, investors, collectors, teams, and alpha groups.

Links

One protected asset.

A private Dropbox-style link backed by wallet verification and expiring sessions.

Screens

Public page, private content.

A branded public page that unlocks into gated files, videos, dashboards, or routes.

KEYCARD Gate

Stop building token gates.

Gate is the developer product path. Hosted unlock pages and REST verification are live; React widgets, no-code embeds, API keys, and webhooks are planned.

gate.json

{
  "name": "Holder Alpha Room",
  "conditions": [
    {
      "type": "spl_balance",
      "mint": "TOKEN_MINT_ADDRESS",
      "min": "10000"
    }
  ],
  "logic": "all"
}

Live

SPL balance gates.

Hosted create flow supports a Solana mint and minimum token balance.

Live

NFT collection verification.

Backend verifier supports Helius DAS collection checks.

Live

Wallet allowlists.

Public create flow supports pasted wallet lists for private holder, team, or investor links.

Planned

SDK and embed widgets.

React components, no-code embed, domain rules, API keys, and webhooks are the developer product path.

react-widget.tsx

import { KeycardGate } from "@keycard/react";

export default function AlphaRoom() {
  return (
    <KeycardGate gateId="gate_alpha_001">
      <PrivateDashboard />
    </KeycardGate>
  );
}

button-mode.tsx

<KeycardButton
  gateId="gate_video_778"
  lockedText="Unlock with wallet"
  unlockedText="Watch now"
/>

embed.html

<script src="https://cdn.keycard.app/gate.js"></script>
<div data-keycard-gate="gate_alpha_001"></div>

Get Access

Do not just deny the user.

Most gates fail because the wallet does not hold enough of the required token or NFT. Keycard should turn failed checks into acquisition paths for projects: show what is missing, explain token risk, and route the user to Jupiter or the project's chosen get-access URL.

Live

Get-access URL.

Hosted gates can include a path to Jupiter, a mint page, or project instructions.

Missing balance copy.

Show exactly how many more tokens a wallet needs before access opens.

Jupiter token metadata.

Surface token verification, liquidity, warnings, and suspicious-token states.

Embedded swap.

Let users swap into the required token inside the unlock flow.

Telegram bot

Token-gate Telegram groups with KEYCARD Sentinel.

Sentinel is the Telegram layer for Keycard. Add it to a group, make it admin, run one setup command, and members verify wallet ownership before they can speak.

Live bot

@keycardsol_bot

Use it for launch rooms, holder chats, CA safety, and token-gated community access.

Add Telegram bot

Add @keycardsol_bot to the Telegram group.
Make the bot an admin with restrict-member permission.
Run /setup keycard in the group.
Members use /verify or the join prompt to connect a Solana wallet.
Use /ca, /buy, /stats, and /recheck for group ops.
Disable Telegram bot privacy in BotFather if the group wants fake-CA scanning on normal messages.

Live

Token-gated joins.

New group members can be muted until they verify wallet ownership through Keycard.

Live

Holder verification links.

The bot sends a signed verify link. The wallet signs once, then the server checks the gate rule.

Live

Official CA commands.

Use /ca in the group to show the official contract address for the configured gate.

Live

Fake-CA warnings.

When message access is enabled and a different Solana address is posted, Sentinel replies with the official CA.

Live

Group stats.

Use /stats to see verified and pending holder counts.

Admin

Holder rechecks.

Admins can recheck holders and keep stale access from staying open.

telegram-env.txt

TELEGRAM_BOT_TOKEN=...
TELEGRAM_WEBHOOK_SECRET=base64url-32-bytes
KEYCARD_SENTINEL_VERIFY_TIMEOUT_SECONDS=300
KEYCARD_SENTINEL_RECHECK_INTERVAL_SECONDS=43200
KEYCARD_TELEGRAM_CARD_IMAGE_URL=https://keycardsol.xyz/og.png

Quickstart

Hosted gate in one minute.

Create a gate at /create.
Set the SPL mint and minimum balance.
Upload the private file.
Share the returned /open/[gateId] URL.
Keep the private manage URL. It contains the admin key.

Create gate

Multipart upload API.

The live create route accepts form data, verifies SPL mint metadata, encrypts the file, stores it privately, and returns both public and private URLs.

create.sh

curl -X POST https://keycardsol.xyz/v1/gates \
  -F "name=Private launch note" \
  -F "description=Only holders can open this file." \
  -F "mint=TOKEN_MINT_ADDRESS" \
  -F "minAmount=1" \
  -F "getAccessUrl=https://pump.fun/coin/TOKEN_MINT_ADDRESS" \
  -F "file=@private.pdf"

allowlist.sh

curl -X POST https://keycardsol.xyz/v1/gates \
  -F "gateType=allowlist" \
  -F "name=Investor deck" \
  -F "description=Only listed wallets can open this file." \
  -F "walletList=wallet_one,wallet_two" \
  -F "file=@deck.pdf"

direct-upload.txt

# For files over 4 MB:
# 1. Browser encrypts the file with AES-GCM.
# 2. Browser uploads encrypted bytes through /v1/uploads.
# 3. Browser finalizes /v1/gates with:
uploadedPathname=client-content/...
uploadedName=private.zip
uploadedType=application/zip
uploadedSize=5242897
uploadedEncryptionKey=base64url-32-byte-key

response.json

{
  "gate": {
    "id": "5f1b...",
    "status": "active",
    "conditions": [{ "type": "spl-balance", "label": "1+ TOKEN" }]
  },
  "openUrl": "/open/5f1b...",
  "adminUrl": "/gates/5f1b..."
}

Unlock flow

Wallet proof first, token check second.

The browser asks the selected Solana wallet for an ed25519 signature over a short-lived Keycard access message. The server validates message shape, wallet match, timestamp freshness, signature, gate status, expiry, and token balance.

message.txt

Keycard access

Gate: 5f1b...
Wallet: wallet-public-key
Issued: 2026-05-20T16:20:00.000Z

API

Routes available now.

POST/v1/gates

Create encrypted gate from multipart form data.

POST/v1/uploads

Issue private Blob client-upload tokens for browser-encrypted large files.

GET/v1/gates/[gateId]

Read public gate metadata.

PATCH/v1/gates/[gateId]

Update gate metadata with wallet proof or legacy adminToken.

POST/v1/verify

Verify wallet signature and token balance.

GET/content/[gateId]

Deliver encrypted content after session validation.

POST/v1/events

Record public view and get-access events.

POST/v1/telegram/webhook

Receive Telegram updates for Sentinel group gates.

POST/v1/telegram/verify

Bind a verified Solana wallet to a Telegram user and open group permissions.

POST/v1/telegram/recheck

Protected holder sweep for configured Telegram groups.

verify-request.json

POST /v1/verify
{
  "gateId": "5f1b...",
  "wallet": "wallet-public-key",
  "message": "Keycard access...",
  "signature": "base58-ed25519-signature"
}

verify-response.json

{
  "access": true,
  "reason": "Wallet passes Private launch note.",
  "matched": ["spl-balance"],
  "expiresAt": "2026-05-20T16:30:00.000Z",
  "contentUrl": "/content/5f1b..."
}

Security model

Wallet connect is not access control.

Keycard treats wallet connection as identity transport, not authorization. Authorization requires a fresh signed message, server-side rule checks, private storage, and short-lived content sessions.

Live

Wallet proof.

Wallet connect alone is not access control. Keycard requires a signed access message.

Live

Short-lived sessions.

A verified wallet receives an HTTP-only access cookie for the gate, not a permanent raw file URL.

Live

Private storage.

Uploaded content is encrypted before private Blob storage and decrypted only after session validation.

Live

Direct encrypted upload.

Large files are encrypted in-browser with per-file keys before private Blob upload.

Planned

Video protection.

Premium video should use encrypted HLS segments, expiring playback sessions, and optional watermarking.

Reality

Revocation limits.

Future access can be revoked after token sales. Already-downloaded files cannot be clawed back.

Admin

Wallet proof first.

API-created gates can use creator wallet signatures for admin updates. Legacy browser-created gates still receive a private manage URL.

Live

SPL balance

Checks Helius token accounts for a minimum balance.

Live

NFT collection

Uses DAS search against collection grouping.

Live

Wallet allowlist

Create flow accepts pasted wallets and verifier checks exact wallet membership.

Partial

AND / OR logic

Gate type supports it; creation UI creates one SPL rule.

Environment

Production variables.

Production should use Vercel Blob, strong content/session secrets, and a Helius RPC URL or Helius API key.

.env

BLOB_READ_WRITE_TOKEN=...
KEYCARD_CONTENT_SECRET=base64url-32-bytes
KEYCARD_SESSION_SECRET=base64url-32-bytes
KEYCARD_LAUNCH_MODE=
NEXT_PUBLIC_KEYCARD_LAUNCH_MODE=
KEYCARD_TOKEN_MINT=...
KEYCARD_TOKEN_SYMBOL=$KEYCARD
KEYCARD_TOKEN_DECIMALS=6
KEYCARD_HOLDER_CHAT_MIN_AMOUNT=1
KEYCARD_TOKEN_GET_ACCESS_URL=https://...
KEYCARD_TOKEN_GATE_IDS=...
SOLANA_RPC_URL=https://mainnet.helius-rpc.com/?api-key=...
# or
HELIUS_API_KEY=...
NEXT_PUBLIC_KEYCARD_DOMAIN=keycardsol.xyz

Roadmap

90 days from token release.

$KEYCARD launches as the access token first: holder chat, rooms, partner gates, issuer utility, API quota, embeds, and webhooks roll out from May 26 through August 24, 2026.

May 26-Jun 9

Launch access network.

$KEYCARD CA, holder chat, holder status checks, launch analytics, and prod wallet reliability checks.

Jun 10-Jun 30

Holder rooms and partner gates.

Public room creation, partner gate templates, missing-balance copy, token metadata, and verified issuer pages.

Jul 1-Jul 31

Issuer utility and gate capacity.

$KEYCARD issuer tiers, gate quotas, creator analytics, API key beta, domain allowlists, and signed admin actions.

Aug 1-Aug 24

Developer access layer.

@keycard/react beta, no-code embed, webhook beta, Token-2022/cNFT hardening, and developer docs.

Open full roadmap

Free

Small creators.

A few gates, starter storage, limited unlock checks, and Keycard branding.

Creator

Drops and media.

More storage, more gates, custom pages, video, and analytics.

Developer

Apps and teams.

API verification, SDK, webhooks, domain allowlists, and higher rate limits.

Protocol

Major launches.

Custom SLA, dedicated RPC/indexing config, white-label gates, moderation, and enterprise controls.

Upload

100 MB direct upload

Files over 4 MB encrypt in-browser and upload directly to private Blob storage.

Wallets

Wallet choice

Phantom, Backpack, and Solflare are supported for ed25519 message signing.

Analytics

Event stream

Backend records create, verify, fail, pass, and download events.

Ownership

Wallet proof

Creator-wallet admin auth is available for API-created gates.