Your app.
Their token launch.

Generate an API key in your developer console. Keep it on your backend and expose only the prepared transaction to the wallet client. The signing wallet pays deployment costs, distributor funding, gas, and any initial buy.

1. Save the launch settings

Replace the wallet and image URL. Use a new idempotency key for each intended token; retry the same request with the same key after a timeout. Save the returned id as LAUNCH_ID.

curl https://revshare.xyz/api/v1/launches \
  -H "Authorization: Bearer $REVSHARE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: my-token-launch-001" \
  -d '{
    "chain": "base",
    "owner": "YOUR_WALLET_ADDRESS",
    "name": "My Token",
    "symbol": "TOKEN",
    "imageUrl": "https://your-project.com/token.png",
    "quote": "native",
    "feePercentage": 1,
    "initialBuy": "0",
    "rewards": { "mode": "shareholders", "reward": "native" },
    "hideOnLaunch": false
  }'

2. Prepare, review, and sign

Preparation creates the distribution wallet and token metadata, simulates the launch where supported, and returns nextStep. Pass that step to the correct wallet integration below.

curl -X POST \
  "https://revshare.xyz/api/v1/launches/$LAUNCH_ID/prepare" \
  -H "Authorization: Bearer $REVSHARE_API_KEY"

3. Submit the result

If the wallet broadcast, send transactionHash. If it only signed, send signedTransaction instead. Include stepId in both cases. A 202 response means the transaction is tracked; it does not mean the token is deployed.

curl "https://revshare.xyz/api/v1/launches/$LAUNCH_ID/submit" \
  -H "Authorization: Bearer $REVSHARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "stepId": "STEP_ID_FROM_PREPARE",
    "transactionHash": "HASH_RETURNED_BY_YOUR_WALLET"
  }'

4. Confirm and continue

Poll confirmation every 3–5 seconds while status is submitted. When it becomes setup_required, call prepare again. Finish when status is complete: result.tokenAddress is the deployed contract and result.tokenUrl is its RevShare page.

curl -X POST \
  "https://revshare.xyz/api/v1/launches/$LAUNCH_ID/confirm" \
  -H "Authorization: Bearer $REVSHARE_API_KEY"

Base path: https://revshare.xyz/api/v1/launches. Launches belong to your developer account. Any active key in that account can resume them.

Read the full OpenAPI schema for request fields and response types. Requests are limited to 256 KiB, 120 requests/minute, and 20 new launches/day per developer account. A rate limit returns 429.

The API returns one transaction at a time. Approvals, custom quote configuration, NEAR storage/setup, or an initial buy may require additional signatures. Always review the recipient, amounts, fees and actions before asking the user to sign.

EVM wallets

Use eth_sendTransaction for connected browser wallets. For sign-only server or hardware integrations, submit the signed transaction as hex. Preserve from, to, data, value, chain ID and nonce. Gas may be increased up to twice the prepared limit; the wallet selects gas pricing.

// Browser: your backend returns the prepared nextStep.
await ethereum.request({
  method: "wallet_switchEthereumChain",
  params: [{ chainId: nextStep.transaction.chainId }],
});
const transactionHash = await ethereum.request({
  method: "eth_sendTransaction",
  params: [nextStep.transaction],
});
// Send { stepId: nextStep.id, transactionHash }
// to your backend, which calls RevShare /submit.

Solana wallets

Decode the base64 legacy transaction and sign its existing message. Keep the provided mint/config signatures and recent blockhash. A wallet that changes the message will be rejected; do not rebuild the transaction.

import { Transaction } from "@solana/web3.js";
import { Buffer } from "buffer";

const transaction = Transaction.from(
  Buffer.from(nextStep.transaction, "base64")
);
const signed = await wallet.signTransaction(transaction);
const signedTransaction = signed.serialize().toString("base64");
// Send { stepId: nextStep.id, signedTransaction }
// to your backend. Preserve the existing mint signatures.

NEAR wallets

Pass the receiver and actions to NEAR Wallet Selector. Sign-only integrations may return a base64 Borsh SignedTransaction. Confirmation checks asynchronous receipts and the launch contract state before advancing.

// A wallet obtained from NEAR Wallet Selector.
const outcome = await wallet.signAndSendTransaction(
  nextStep.transaction
);
const transactionHash = outcome.transaction.hash;
// Send { stepId: nextStep.id, transactionHash }
// to your backend. Redirect wallets must recover the
// transaction hash from their callback before continuing.

Settings become immutable when the launch record is created. NEAR graduation is informational; its Rhea pool can trade before and after that marker. EVM smart-account UserOperations are not supported by this API.

A signed transaction may remain valid after your HTTP request ends. Re-submit the same bytes to retry relay. Never assume a timeout revoked a signature. If a Solana blockhash expires or an EVM nonce is consumed by another transaction, keep the launch ID and transaction hash for recovery.

RevShare never needs the owner’s private key or seed phrase. A signature authorizes a specific transaction, so the API compares submitted contents to the saved plan and verifies the chain result before registration.

• Keep API keys in your backend. They identify your application; wallet signatures authorize spending.
• Bind each launch ID to your own authenticated user. Every active key in your developer account can access that account’s API launches.
• Show the transaction summary in your UI and verify the expected chain, contracts, amounts and recipient in the wallet.
• Persist idempotency keys and transaction hashes. Resume existing launches after retries and restarts.
• Distribution wallets remain managed by the existing RevShare rewards service. This API does not change that custody model.

These checks reduce risk; they do not make a transaction service risk-free. Contract bugs, compromised applications, and malicious approvals still matter. Use controlled integration tests before enabling launches for customers.