> ## Documentation Index
> Fetch the complete documentation index at: https://docs.rampnow.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Integrations Overview

> Three ways to add Rampnow onramp and offramp to your product, and how to choose between them

export const LiveTokenCount = ({flow, fallback = "multiple", configUrl}) => {
  const {tokenCount, loading, error} = useCoverageStats(flow, configUrl);
  if (loading || error || tokenCount == null) return <>{fallback}</>;
  return <>{tokenCount}</>;
};

export const LiveChainCount = ({flow, fallback = "multiple", configUrl}) => {
  const {chainCount, loading, error} = useCoverageStats(flow, configUrl);
  if (loading || error || chainCount == null) return <>{fallback}</>;
  return <>{chainCount}</>;
};

export const useCoverageStats = (flow, configUrl) => {
  const [tokenCount, setTokenCount] = useState(null);
  const [chainCount, setChainCount] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);
  useEffect(() => {
    fetch(configUrl).then(res => {
      if (!res.ok) throw new Error("Failed to load config");
      return res.json();
    }).then(json => {
      const assetConfigs = json?.data?.assetConfigs || ({});
      let tokenListingCount = 0;
      const chains = new Set();
      Object.entries(assetConfigs).forEach(([assetKey, assetConfig]) => {
        if (typeof assetKey !== "string" || !assetKey.includes(":")) return;
        const orderTypeConfig = assetConfig?.orderTypeConfigs || ({});
        const buyActive = orderTypeConfig?.buy?.status?.toLowerCase() === "active";
        const sellActive = orderTypeConfig?.sell?.status?.toLowerCase() === "active";
        const isActive = flow === "buy" ? buyActive : flow === "sell" ? sellActive : buyActive || sellActive;
        if (!isActive) return;
        const [symbol, chainRaw] = assetKey.split(":");
        const chain = chainRaw?.trim();
        if (!chain || chain === "fiat") return;
        if (symbol) tokenListingCount += 1;
        chains.add(chain);
      });
      setTokenCount(tokenListingCount);
      setChainCount(chains.size);
      setLoading(false);
    }).catch(() => {
      setError("Unable to load coverage stats");
      setLoading(false);
    });
  }, [configUrl, flow]);
  return {
    tokenCount,
    chainCount,
    loading,
    error
  };
};

export const CONFIG_URL = "https://api.rampnow.io/api/ramp/v1/ramp_order/quote/config?apiKey=pk_live_zXuMmMzFAbfnMPQnwfEaMkabwPfKsVsg";

export const ChainCount = () => {
  return <LiveChainCount flow="buy" configUrl={CONFIG_URL} />;
};

export const TokenCount = () => {
  return <LiveTokenCount flow="buy" configUrl={CONFIG_URL} />;
};

Rampnow lets your users buy and sell crypto without leaving your product. Every integration covers both directions:

* **Onramp (buy):** the user pays with fiat and receives crypto in their wallet.
* **Offramp (sell):** the user sends crypto and receives fiat in their bank account.

You pick the direction per order with `orderType` (`buy` or `sell`). Rampnow runs payment, KYC, liquidity, on-chain delivery and bank payouts behind it.

## Choose an integration

There are three ways to integrate. They differ in how much of the experience you build yourself.

<div style={{display: 'grid', gridTemplateColumns: '1fr 1fr 1fr', gap: '1rem'}}>
  <Card title="Onramp & Offramp Widget" icon="window" href="/quickstart/ramp-widget/overview">
    Embed the Rampnow widget with a URL or an iframe. No code beyond a link
  </Card>

  <Card title="Onramp & Offramp SDK" icon="cube" href="/quickstart/ramp-sdk/overview">
    Open the Rampnow widget from JavaScript, with typed config, browser events and a React hook
  </Card>

  <Card title="Onramp & Offramp Intent" icon="code" href="/quickstart/ramp-intent/overview">
    Create orders from your backend and send the user to Rampnow's hosted checkout
  </Card>
</div>

| | Widget | SDK | Intent API |
| - | - | - | - |
| **You build** | A URL or an iframe with query parameters | A few lines of JavaScript with `@rampnow/sdk` | Your own screens, plus server-to-server quote and order calls |
| **Rampnow handles** | The whole buy and sell UI, payment, KYC | The whole buy and sell UI, payment, KYC | Hosted checkout: payment, KYC, settlement |
| **Credentials** | Public partner key (`apiKey`) | Public partner key (`apiKey`) | API key and secret, signed requests |
| **Backend needed** | No (webhooks recommended) | No (webhooks recommended) | Yes |
| **Order updates** | Webhooks | Browser events and webhooks | Webhooks and polling |
| **Best for** | The fastest launch with the least code | Web apps that want events, programmatic control and React | Platforms that own the pre-checkout journey and hold user data |

<Tip>
  The SDK is a wrapper around the widget. Both open the same Rampnow flow and accept the same [parameters](/quickstart/ramp-widget/parameters). Start with the widget if you only need a link or an iframe; move to the SDK when you need events or open/close control.
</Tip>

All three share the same order lifecycle, [webhooks](/api-reference/webhook), [order statuses](/api-reference/order-status), [sandbox](/api-reference/sandbox-testing) and [supported assets, payment methods and countries](/quickstart/resources/supported-assets).

## What you handle and what Rampnow handles

<Tabs>
  <Tab title="SDK and Widget">
    <div style={{display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '1rem'}}>
      <Card title="You" icon="code">
        * Your partner API key on every widget session
        * The entry point in your app, plus any asset, amount or wallet address you pre-fill
        * Your own order ID (`externalOrderId`), to reconcile orders with your records
        * A webhook endpoint that receives order status changes
      </Card>

      <Card title="Rampnow" icon="shield-check">
        * The whole user interface inside the widget
        * User verification: email/OTP and KYC, skipped for users who are already verified
        * Payment capture on buy orders, crypto collection on sell orders, FX and liquidity routing
        * Delivery of crypto to the user's wallet, or fiat to the user's bank account
        * AML and on-chain risk screening on every order
      </Card>
    </div>
  </Tab>

  <Tab title="Intent">
    <div style={{display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '1rem'}}>
      <Card title="You" icon="code">
        * Request signing with your API key and secret
        * The quote, asset picker and user details screens
        * Creating the order server-to-server and redirecting the user
        * A webhook endpoint, or polling, to track the order
      </Card>

      <Card title="Rampnow" icon="shield-check">
        * The hosted checkout page: payment and KYC
        * Payment capture, crypto collection, FX and liquidity routing
        * Delivery of crypto or fiat, and the return to your `returnUrl`
        * AML and on-chain risk screening on every order
      </Card>
    </div>
  </Tab>
</Tabs>

## Why choose Rampnow?

<div style={{display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '1rem'}}>
  <Card title="Global Coverage" icon="globe">
    **{<ChainCount />} blockchains** and **{<TokenCount />} assets** with EVM and non-EVM support
  </Card>

  <Card title="Complete Payment Methods" icon="credit-card">
    Cards, bank transfers, Apple Pay, Google Pay and **local APMs** for buying. SEPA bank payouts for selling
  </Card>

  <Card title="One integration, both directions" icon="arrows-left-right">
    Same order lifecycle and webhooks for buy and sell orders
  </Card>

  <Card title="Enterprise Reliability" icon="bolt">
    High-availability routing with **predictable fees** and real-time status updates
  </Card>
</div>

## Core capabilities

<Tabs>
  <Tab title="Onramp (buy)">
    ### <Icon icon="chart-line" /> Instant quotes

    * Real-time FX rates
    * Network and payment method fees
    * Slippage controls
    * Guaranteed execution rates

    ### <Icon icon="wallet" /> Global payment acceptance

    * **Cards**: Visa, Mastercard
    * **Digital wallets**: Apple Pay, Google Pay
    * **Bank transfers**: SEPA, ACH, PIX, UPI
    * **Local APMs**: Auto-adjusted by region and currency

    ### <Icon icon="link" /> Blockchain delivery

    * Liquidity provider routing
    * On-chain execution preparation
    * Direct wallet delivery
    * Full transaction metadata confirmation

    ### <Icon icon="lock" /> Security

    * Device fingerprinting
    * Behavioral risk scoring
    * Payment fraud checks
    * Beneficiary wallet screening
  </Tab>

  <Tab title="Offramp (sell)">
    ### <Icon icon="calculator" /> Quote & eligibility checks

    Before a sell order is created, Rampnow validates the asset and chain, checks corridor availability and returns the fiat amount, fees and FX, estimated delivery time and applicable limits. You can show users **exactly what they will receive** before they send anything.

    ### <Icon icon="wallet" /> Asset collection

    * **User-initiated transfer**: the user sends assets from their wallet to a Rampnow-provided address.
    * **Platform-initiated transfer**: you send assets from a custody or omnibus wallet after the user confirms.

    Each order is tied to a unique reference for deterministic matching and reconciliation.

    ### <Icon icon="arrows-rotate" /> FX & treasury routing

    Once assets are confirmed on-chain, Rampnow converts them into EUR using connected liquidity, routes funds via SEPA and applies risk-based checks and velocity limits.

    ### <Icon icon="building-columns" /> Fiat payout

    Users receive fiat by **bank transfer** (SEPA). Each order emits a webhook on every status change. See [Order Status](/api-reference/order-status).

    ### <Icon icon="file-invoice" /> Reporting & reconciliation

    * Order-level records (asset, chain, user, fiat, fees)
    * Payout references and bank trace IDs
    * Exportable data for accounting and tax reporting
  </Tab>
</Tabs>

## Use cases

<div style={{display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '1rem'}}>
  <Card title="Wallets" icon="wallet">
    Let users buy assets inside the wallet, and cash out to their bank when they need fiat.
  </Card>

  <Card title="Exchanges" icon="exchange">
    Support instant fiat deposits into digital asset accounts, and withdrawals back to the bank.
  </Card>

  <Card title="NFT Marketplaces" icon="artstation">
    Provide smooth purchase flows for first-time Web3 users without crypto friction.
  </Card>

  <Card title="Gaming" icon="gamepad">
    Allow players to acquire in-game assets or tokens with fiat for better onboarding.
  </Card>

  <Card title="Fintech" icon="money-bill">
    Add digital asset investment and cash-out features to banking and neobank applications.
  </Card>

  <Card title="Payments" icon="arrow-right-from-arc">
    Use the onramp and offramp as entry and exit points for cross-border transfers and settlement.
  </Card>
</div>

## From sandbox to live

<Steps>
  <Step title="Get your partner account">
    Ask [support@rampnow.io](mailto:support@rampnow.io) for a partner account. Your keys are in the [Partner Dashboard](https://partner.rampnow.io) under **API Hub**.
  </Step>

  <Step title="Build your integration">
    Follow the [Widget](/quickstart/ramp-widget/overview), [SDK](/quickstart/ramp-sdk/overview) or [Intent](/quickstart/ramp-intent/overview) guide. Set `orderType` to `buy` or `sell`.
  </Step>

  <Step title="Set up webhooks">
    Add your endpoint in the Partner Dashboard and verify signatures. See the [Webhook guide](/api-reference/webhook).
  </Step>

  <Step title="Test in sandbox">
    Cover completed, failed and expired orders in both directions. See [Sandbox Testing](/api-reference/sandbox-testing).
  </Step>

  <Step title="Go live">
    Work through the [Go-Live Checklist](/api-reference/go-live-checklist), then ask support for production access.
  </Step>
</Steps>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.