Quickstart

Go from registering an app to a confirmed on-chain buy in five steps.

This guide walks you through connecting a user, placing a buy on the Trench bonding curve, and confirming that it landed on-chain.

Prerequisites

Before starting, make sure you have:

• An app registered at tren.ch/partner, which gives you a client_id and an API key. See Registration.
• A redirect URI on the app, matching exactly what you will send.
• The profile:read and trade:execute scopes selected for the app.
• A Trench user to connect, with 1-click trading enabled and some SOL in their wallet.
• A Solana RPC endpoint, which you will use to confirm that trades landed.

Trench does not provide a sandbox environment. A client in development status trades real SOL against mainnet, so we recommend testing with small amounts on a wallet you control.

Endpoints Used

• POST /oauth/token
• GET /partner/v1/me
• POST /partner/v1/trades/buy

1. Set Up Environment Variables

# .env
TRENCH_CLIENT_ID=tclient_your_client_id
TRENCH_API_KEY=trench_cs_your_api_key
TRENCH_REDIRECT_URI=https://yourapp.com/oauth/callback
TRENCH_API=https://api.tren.ch
SOLANA_RPC_URL=https://your-rpc-provider

Your API key should only ever be used server-side. If it reaches a browser bundle, treat it as compromised: create a replacement key in the portal, deploy it, then revoke the leaked one.

2. Connect a User

Run the connect flow to obtain an authorization code, then exchange that code for a token pair.

cURL

curl -X POST "$TRENCH_API/oauth/token" \
  -u "$TRENCH_CLIENT_ID:$TRENCH_API_KEY" \
  -d grant_type=authorization_code \
  -d code=trench_ac_YOUR_CODE \
  -d redirect_uri="$TRENCH_REDIRECT_URI" \
  -d code_verifier=YOUR_VERIFIER

Store the returned access_token and refresh_token against your own user record.

3. Verify the Token

cURL

curl "$TRENCH_API/partner/v1/me" \
  -H "Authorization: Bearer $ACCESS_TOKEN"

{
  "user": {
    "walletSolana": "…",
    "twitterHandle": "…",
    "tradingEnabled": true
  },
  "client": "tclient_…",
  "scopes": ["profile:read", "trade:execute"]
}

There are two things worth checking before you attempt a trade: that tradingEnabled is true, and that scopes includes trade:execute.

Keep walletSolana on hand as well, since you will need it to read the user’s balances and transaction history from your RPC.

4. Place a Buy

All amounts are sent as integer strings in base units, using lamports for SOL and 1e6 units for tokens. See Amount Conventions for details.

cURL

curl -X POST "$TRENCH_API/partner/v1/trades/buy" \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "mint": "YOUR_TOKEN_MINT",
    "maxSolIn": "100000000",
    "slippageBps": 100,
    "priorityFeeLamports": "20000",
    "tipLamports": "1000000"
  }'

Response

{ "signature": "…", "mint": "…", "status": "submitted" }

slippageBps is your protection against the price moving between quoting and execution. Trench takes a quote when the trade executes, derives the minimum tokens it must return, and fails with slippage_exceeded rather than filling worse. If you would rather compute that bound yourself, omit slippageBps and send minTokensOut instead.

If you want to take a cut of the trade, add partnerFeeBps to the request body. See Partner Fees.

5. Confirm It Landed

A status of submitted means the network accepted the transaction, not that it succeeded. Confirmation is public on-chain state, so you read it from Solana directly using the signature Trench returned.

Node.js

import { Connection } from "@solana/web3.js";

const connection = new Connection(process.env.SOLANA_RPC_URL, "confirmed");

async function waitForTrade(signature) {
  for (let i = 0; i < 30; i++) {
    const { value } = await connection.getSignatureStatuses([signature]);
    const status = value[0];

    if (status?.err) throw new Error(`Trade failed: ${JSON.stringify(status.err)}`);

    if (status?.confirmationStatus === "confirmed" || status?.confirmationStatus === "finalized") {
      return status;
    }

    await new Promise((r) => setTimeout(r, 1000));
  }

  throw new Error("Timed out waiting for confirmation");
}

Once the transaction has confirmed, the token balance changes recorded on it tell you what the user actually received.

Node.js

const tx = await connection.getParsedTransaction(signature, {
  maxSupportedTransactionVersion: 0,
});

const { preTokenBalances, postTokenBalances } = tx.meta;

The Partner API does not support idempotency keys, so sending the same trade twice will execute it twice. If a request times out before you receive a signature, check the user’s recent transactions on-chain to see whether it landed before trying again.

Next Steps

Trade Tokens

Exact-out buys, sells, and volume caps.

Partner Fees

Charge your own fee on every trade.

Governance

Read proposals and vote on behalf of a user.

Security Requirements

Recommended reading before going to production.