# Authentication
Source: https://docs.rampnow.io/api-reference/authentication

Access to APIs and Authentication

<Note>
  To start working with the Rampnow API, all clients must authenticate with valid keys provided in the Rampnow partner dashboard.
</Note>

An app token is a secure method of communication with our API. You can create an app token in the Partner Dashboard.

### Environments

| Environment | API base URL                     | Widget host                      |
| ----------- | -------------------------------- | -------------------------------- |
| Production  | `https://api.rampnow.io`         | `https://app.rampnow.io`         |
| Sandbox     | `https://api.sandbox.rampnow.io` | `https://app.sandbox.rampnow.io` |

<Warning>
  Keys are environment-scoped: a sandbox key must be used against the sandbox hosts (`*.sandbox.rampnow.io`) — for both the API and the widget — and a production key against the production hosts. A sandbox key will not work on production hosts, or vice versa.
</Warning>

### Make requests

Authentication to Rampnow's API is performed via the custom HTTP header

| Property            | Description                                                               |
| ------------------- | ------------------------------------------------------------------------- |
| X-RAMPNOW-API-KEY   | an API Key that you generate in the Dashboard                             |
| X-RAMPNOW-SIGN      | a request signature in the HEX format. The signature is case insensitive. |
| X-RAMPNOW-TIMESTAMP | number of seconds since Unix Epoch in UTC.                                |

<Note>
  All API queries must be sent over HTTPS; plain HTTP will be refused. You must include your auth headers in all requests.
</Note>

### Sign requests

The value of the X-RAMPNOW-SIGN header is generated with the sha256 HMAC algorithm using a secret key (Secret key is generated in the merchant Dashboard as part of API key creation) on the bytes obtained by concatenating the following information:

<Info>
  All API requests must be signed using HMAC-SHA256 with your secret key. The signature ensures request authenticity and prevents tampering.
</Info>

### How Request Signing Works

Every API request requires two headers:

* `X-RAMPNOW-TIMESTAMP`: Current Unix timestamp
* `X-RAMPNOW-SIGN`: HMAC-SHA256 signature of your request

The signature is generated using your secret key (obtained from the merchant Dashboard during API key creation) on a message constructed from your request details.

### Signing Your Requests

<Steps>
  <Step title="Generate timestamp">
    Create a Unix timestamp value for the `X-RAMPNOW-TIMESTAMP` header.
  </Step>

  <Step title="Construct the message">
    Concatenate the following in order:

    1. Timestamp (as a string)
    2. HTTP method in uppercase (e.g., `GET`, `POST`)
    3. URI path with query parameters (e.g., `/api/partner/v1/ext/ramp_order/quote?srcCurrency=USD&dstCurrency=BTC`)
    4. Request body (if present, exactly as it will be sent)
  </Step>

  <Step title="Generate HMAC signature">
    Create an HMAC-SHA256 hash of the message using your secret key and set it as the `X-RAMPNOW-SIGN` header value.
  </Step>
</Steps>

<Warning>
  Your timestamp must be within 1 minute of the API server time. Ensure your server time is correctly synchronized.
</Warning>

### Examples of how you can sign your requests:

```python Python theme={null}
message = timestamp + 'POST' + url_path + body
hmac_message = hmac.digest(SECRET_KEY.encode(), message.encode(), hashlib.sha256)
```

### Code Examples

<CodeGroup>
  ```python Python theme={null}
  import time
  import base64
  import hashlib
  import hmac
  import json
  import requests

  SECRET_KEY = 'api-secret-key'
  API_KEY = 'api-key'
  base_url = 'https://api.rampnow.io' 
  path = '/api/partner/v1/ext/ramp_order/quote'

  # Prepare request data
  payload_data = {
      "orderType": "buy",  
      "srcAmount": "100.0",  
      "srcCurrency": "EUR",
      "srcChain": "fiat",  
      "dstChain": "ethereum", 
      "dstCurrency": "ETH", 
      "paymentMode": "card", 
      "apiKey": API_KEY,
      "walletAddress": "0x6782f3309EAE59BbffbE87d9f3d4117298861468", 
      "walletAddressTag": "",  
      "externalOrderId": "ajsdiauhdiqw7e78322wrnbjsahd", 
  }
  # Prepare request body
  payload = json.dumps(payload_data)

  # Generate timestamp
  timestamp = str(int(time.time()))
  # Construct message
  message = timestamp + 'POST' + path + payload
  # Generate HMAC signature
  signature = base64.b16encode(hmac.digest(SECRET_KEY.encode(), message.encode(), hashlib.sha256)).decode().lower()

  # Set headers
  headers = {
      'X-RAMPNOW-TIMESTAMP': timestamp,
      'X-RAMPNOW-SIGN': signature,
      'X-RAMPNOW-API-KEY': API_KEY,
      'Content-Type': 'application/json'
  }

  # Make request
  url = base_url + path
  response = requests.post(url, headers=headers, data=payload)
  print(response.status_code, response.text) 

  # Expected output for verification:
  # Timestamp: 1772080882
  # X-RAMPNOW-SIGN: 64-char hex HMAC of the EXACT bytes shown above. Different JSON
  #   formatting (key order/whitespace) yields a different, still-valid signature —
  #   always sign the body you actually send, byte for byte.

  ```

  ```javascript Node.js theme={null}
  const crypto = require('crypto');
  const https = require('https');

  const SECRET_KEY = 'api-secret-key';
  const API_KEY = 'api-key';
  const baseUrl = 'https://api.rampnow.io';
  const path = '/api/partner/v1/ext/ramp_order/quote';

  // Prepare request data
  const payloadData = {
    orderType: "buy",
    srcAmount: "100.0",
    srcCurrency: "EUR",
    srcChain: "fiat",
    dstChain: "ethereum",
    dstCurrency: "ETH",
    paymentMode: "card",
    apiKey: API_KEY,
    walletAddress: "0x6782f3309EAE59BbffbE87d9f3d4117298861468",
    walletAddressTag: "",
    externalOrderId: "ajsdiauhdiqw7e78322wrnbjsahd",
  };

  // Prepare request body
  const payload = JSON.stringify(payloadData);

  // Generate timestamp
  const timestamp = String(Math.floor(Date.now() / 1000));

  // Construct message
  const message = timestamp + 'POST' + path + payload;

  // Generate HMAC signature
  const signature = crypto
    .createHmac('sha256', SECRET_KEY)
    .update(message)
    .digest('hex');

  // Set headers
  const headers = {
    'X-RAMPNOW-TIMESTAMP': timestamp,
    'X-RAMPNOW-SIGN': signature,
    'X-RAMPNOW-API-KEY': API_KEY,
    'Content-Type': 'application/json'
  };

  // Make request
  const url = new URL(baseUrl + path);
  const options = {
    hostname: url.hostname,
    port: 443,
    path: url.pathname,
    method: 'POST',
    headers: headers
  };

  const req = https.request(options, (res) => {
    let data = '';
    res.on('data', (chunk) => {
      data += chunk;
    });
    res.on('end', () => {
      console.log(res.statusCode, data);
    });
  });

  req.on('error', (error) => {
    console.error(error);
  });

  req.write(payload);
  req.end();

  // Expected output for verification:
  // Timestamp: 1772080882
  // X-RAMPNOW-SIGN: 64-char hex HMAC of the EXACT bytes shown above. Different JSON
  //   formatting (key order/whitespace) yields a different, still-valid signature —
  //   always sign the body you actually send, byte for byte.

  ```

  ```go Go theme={null}
  package main

  import (
  	"bytes"
  	"crypto/hmac"
  	"crypto/sha256"
  	"encoding/hex"
  	"encoding/json"
  	"fmt"
  	"io"
  	"net/http"
  	"time"
  )

  func main() {
  	secretKey := "api-secret-key"
  	apiKey := "api-key"
  	baseURL := "https://api.rampnow.io"
  	path := "/api/partner/v1/ext/ramp_order/quote"

  	// Prepare request data
  	payloadData := map[string]any{
  		"orderType":       "buy",
  		"srcAmount":       "100.0",
  		"srcCurrency":     "EUR",
  		"srcChain":        "fiat",
  		"dstChain":        "ethereum",
  		"dstCurrency":     "ETH",
  		"paymentMode":     "card",
  		"apiKey":          apiKey,
  		"walletAddress":   "0x6782f3309EAE59BbffbE87d9f3d4117298861468",
  		"walletAddressTag": "",
  		"externalOrderId": "ajsdiauhdiqw7e78322wrnbjsahd",
  	}

  	// Prepare request body
  	payload, _ := json.Marshal(payloadData)

  	// Generate timestamp
  	timestamp := fmt.Sprintf("%d", time.Now().Unix())

  	// Construct message
  	message := timestamp + "POST" + path + string(payload)

  	// Generate HMAC signature
  	h := hmac.New(sha256.New, []byte(secretKey))
  	h.Write([]byte(message))
  	signature := hex.EncodeToString(h.Sum(nil))

  	// Set headers
  	req, _ := http.NewRequest("POST", baseURL+path, bytes.NewBuffer(payload))
  	req.Header.Set("X-RAMPNOW-TIMESTAMP", timestamp)
  	req.Header.Set("X-RAMPNOW-SIGN", signature)
  	req.Header.Set("X-RAMPNOW-API-KEY", apiKey)
  	req.Header.Set("Content-Type", "application/json")

  	// Make request
  	client := &http.Client{}
  	resp, _ := client.Do(req)
  	defer resp.Body.Close()

  	body, _ := io.ReadAll(resp.Body)
  	fmt.Println(resp.StatusCode, string(body))
  }

  // Expected output for verification:
  // Timestamp: 1772080882
  // X-RAMPNOW-SIGN: 64-char hex HMAC of the EXACT bytes shown above. Different JSON
  //   formatting (key order/whitespace) yields a different, still-valid signature —
  //   always sign the body you actually send, byte for byte.

  ```

  ```java Java theme={null}
  import javax.crypto.Mac;
  import javax.crypto.spec.SecretKeySpec;
  import java.net.URI;
  import java.net.http.HttpClient;
  import java.net.http.HttpRequest;
  import java.net.http.HttpResponse;
  import java.nio.charset.StandardCharsets;
  import java.time.Instant;
  import java.util.HexFormat;
  import com.google.gson.Gson;
  import java.util.HashMap;
  import java.util.Map;

  public class RampnowAPI {
      public static void main(String[] args) throws Exception {
          String secretKey = "api-secret-key";
          String apiKey = "api-key";
          String baseUrl = "https://api.rampnow.io";
          String path = "/api/partner/v1/ext/ramp_order/quote";

          // Prepare request data
          Map<String, Object> payloadData = new HashMap<>();
          payloadData.put("orderType", "buy");
          payloadData.put("srcAmount", "100.0");
          payloadData.put("srcCurrency", "EUR");
          payloadData.put("srcChain", "fiat");
          payloadData.put("dstChain", "ethereum");
          payloadData.put("dstCurrency", "ETH");
          payloadData.put("paymentMode", "card");
          payloadData.put("apiKey", apiKey);
          payloadData.put("walletAddress", "0x6782f3309EAE59BbffbE87d9f3d4117298861468");
          payloadData.put("walletAddressTag", "");
          payloadData.put("externalOrderId", "ajsdiauhdiqw7e78322wrnbjsahd");

          // Prepare request body
          Gson gson = new Gson();
          String payload = gson.toJson(payloadData);

          // Generate timestamp
          String timestamp = String.valueOf(Instant.now().getEpochSecond());

          // Construct message
          String message = timestamp + "POST" + path + payload;

          // Generate HMAC signature
          Mac hmacSha256 = Mac.getInstance("HmacSHA256");
          SecretKeySpec secretKeySpec = new SecretKeySpec(
              secretKey.getBytes(StandardCharsets.UTF_8), 
              0, 
              secretKey.getBytes(StandardCharsets.UTF_8).length, 
              "HmacSHA256"
          );
          hmacSha256.init(secretKeySpec);
          byte[] hmacBytes = hmacSha256.doFinal(message.getBytes(StandardCharsets.UTF_8));
          String signature = HexFormat.of().formatHex(hmacBytes);

          // Create HTTP request
          HttpRequest request = HttpRequest.newBuilder()
              .uri(URI.create(baseUrl + path))
              .POST(HttpRequest.BodyPublishers.ofString(payload))
              .header("X-RAMPNOW-TIMESTAMP", timestamp)
              .header("X-RAMPNOW-SIGN", signature)
              .header("X-RAMPNOW-API-KEY", apiKey)
              .header("Content-Type", "application/json")
              .build();

          // Make request
          HttpClient client = HttpClient.newHttpClient();
          HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
          
          System.out.println(response.statusCode() + " " + response.body());
      }
  }

  // Expected output for verification:
  // Timestamp: 1772080882
  // X-RAMPNOW-SIGN: 64-char hex HMAC of the EXACT bytes shown above. Different JSON
  //   formatting (key order/whitespace) yields a different, still-valid signature —
  //   always sign the body you actually send, byte for byte.

  ```
</CodeGroup>

## Quick Reference

| Component    | Description                                             |
| ------------ | ------------------------------------------------------- |
| Secret Key   | Generated in merchant Dashboard during API key creation |
| Timestamp    | Unix timestamp, must be within 1 minute of server time  |
| HTTP Method  | Uppercase method name (GET, POST, etc.)                 |
| URI Path     | Full path with query parameters, starting with /        |
| Request Body | Exact body as sent (omit for GET requests)              |


# GetAssetConfig
Source: https://docs.rampnow.io/api-reference/configuration/getassetconfig

/api-reference/partner_external.yaml get /api/partner/v1/ext/ramp_order/asset_config



# GetBlockedCurrencies
Source: https://docs.rampnow.io/api-reference/configuration/getblockedcurrencies

/api-reference/partner_external.yaml get /api/partner/v1/ext/ramp_order/blocked_currencies



# GetChainConfig
Source: https://docs.rampnow.io/api-reference/configuration/getchainconfig

/api-reference/partner_external.yaml get /api/partner/v1/ext/ramp_order/chain_config



# GetPaymentModeConfig
Source: https://docs.rampnow.io/api-reference/configuration/getpaymentmodeconfig

/api-reference/partner_external.yaml get /api/partner/v1/ext/ramp_order/payment_mode_config



# GetRampOrderConfig
Source: https://docs.rampnow.io/api-reference/configuration/getramporderconfig

/api-reference/partner_external.yaml get /api/partner/v1/ext/ramp_order/config



# GetTokenConfig
Source: https://docs.rampnow.io/api-reference/configuration/gettokenconfig

/api-reference/partner_external.yaml get /api/partner/v1/ext/ramp_order/token_config



# Error Codes
Source: https://docs.rampnow.io/api-reference/error-codes

Exhaustive list of possible error codes

## Overview

The Rampnow API returns standard HTTP status codes to indicate the success or failure of API requests. These codes are returned by the server and provide immediate feedback about your request.

<Info>
  HTTP status codes are different from application error codes. Status codes indicate the HTTP-level result, while error codes provide specific application-level details.
</Info>

## Error Response Body

Every failed request returns the standard envelope with an application `code` and two message fields:

```json theme={null}
{
  "code": 100004,
  "message": "invalid_args_err",
  "displayError": "Amount is below the minimum for this route.",
  "traceId": "b1f2c3d4-..."
}
```

| Field          | Description                                                                                                                                                                                                                |
| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `code`         | Application error code — **branch your logic on this**, not on message text. See the tables below.                                                                                                                         |
| `message`      | A stable, generic label for the `code`. It is safe to log but **never** contains internal or upstream-provider error detail.                                                                                               |
| `displayError` | Optional human-readable message safe to show your end user (e.g. "Amount is below the minimum for this route."). Present only when a user-facing message applies; when absent, fall back to your own copy keyed on `code`. |
| `traceId`      | Identifier for the request in Rampnow logs — include it when contacting support.                                                                                                                                           |

<Warning>
  Do not parse `message` for meaning or display it to end users — it is a generic code label and its exact text may change. Use `code` programmatically and `displayError` (or your own copy) for user-facing text.
</Warning>

## API Status Code Categories

### 2xx - Success

<AccordionGroup>
  <Accordion title="200 OK" icon="check">
    **Success**

    The request was successful and the server returned the requested data.

    ```json theme={null}
    {
      "code": 0,
      "data": { ... }
    }
    ```
  </Accordion>

  <Accordion title="201 Created" icon="plus">
    **Resource Created**

    The request was successful and a new resource was created.
  </Accordion>

  <Accordion title="204 No Content" icon="circle-check">
    **Success with No Content**

    The request was successful but there is no content to return.
  </Accordion>
</AccordionGroup>

### 4xx - Client Errors

<AccordionGroup>
  <Accordion title="400 Bad Request" icon="circle-xmark">
    **Invalid Request**

    The request is malformed or contains invalid parameters. Check your request payload and parameters.

    **Common causes:**

    * Missing required fields
    * Invalid JSON format
    * Incorrect data types
  </Accordion>

  <Accordion title="401 Unauthorized" icon="lock">
    **Authentication Failed**

    Authentication credentials are missing or invalid.

    **Common causes:**

    * Missing `X-RAMPNOW-API-KEY` header
    * Invalid API key
    * Missing or incorrect signature
    * Expired timestamp
  </Accordion>

  <Accordion title="403 Forbidden" icon="ban">
    **Access Denied**

    You don't have permission to access this resource.

    **Common causes:**

    * Insufficient account permissions
    * API key doesn't have required scope
    * IP address not whitelisted
  </Accordion>

  <Accordion title="404 Not Found" icon="magnifying-glass">
    **Resource Not Found**

    The requested resource doesn't exist.

    **Common causes:**

    * Incorrect endpoint URL
    * Invalid resource ID
    * Resource has been deleted
  </Accordion>

  <Accordion title="422 Unprocessable Entity" icon="triangle-exclamation">
    **Validation Error**

    The request is well-formed but contains semantic errors.

    **Common causes:**

    * Business logic validation failed
    * Invalid currency pair
    * Amount outside allowed range
  </Accordion>

  <Accordion title="429 Too Many Requests" icon="gauge-high">
    **Rate Limit Exceeded**

    You have exceeded the API rate limit.

    **Solution:** Wait before making additional requests. Check the `Retry-After` header for guidance.
  </Accordion>
</AccordionGroup>

### 5xx - Server Errors

<AccordionGroup>
  <Accordion title="500 Internal Server Error" icon="server">
    **Server Error**

    An unexpected error occurred on the server.

    **Action:** Retry the request. If the issue persists, contact support with your request details.
  </Accordion>

  <Accordion title="502 Bad Gateway" icon="network-wired">
    **Bad Gateway**

    The server received an invalid response from an upstream server.

    **Action:** This is usually temporary. Retry the request after a short delay.
  </Accordion>

  <Accordion title="503 Service Unavailable" icon="circle-exclamation">
    **Service Unavailable**

    The service is temporarily unavailable, usually due to maintenance or overload.

    **Action:** Retry the request after some time. Check the `Retry-After` header if provided.
  </Accordion>

  <Accordion title="504 Gateway Timeout" icon="clock">
    **Gateway Timeout**

    The server didn't receive a timely response from an upstream server.

    **Action:** Retry the request. Consider reducing payload size if applicable.
  </Accordion>
</AccordionGroup>

## Status Code Reference Table

| Status Code | Status Text           | Category     | Description                          |
| ----------- | --------------------- | ------------ | ------------------------------------ |
| 200         | OK                    | Success      | Request successful                   |
| 201         | Created               | Success      | Resource created successfully        |
| 204         | No Content            | Success      | Success with no response body        |
| 400         | Bad Request           | Client Error | Invalid request format or parameters |
| 401         | Unauthorized          | Client Error | Authentication required or failed    |
| 403         | Forbidden             | Client Error | Access denied                        |
| 404         | Not Found             | Client Error | Resource not found                   |
| 422         | Unprocessable Entity  | Client Error | Validation error                     |
| 429         | Too Many Requests     | Client Error | Rate limit exceeded                  |
| 500         | Internal Server Error | Server Error | Unexpected server error              |
| 502         | Bad Gateway           | Server Error | Invalid upstream response            |
| 503         | Service Unavailable   | Server Error | Service temporarily unavailable      |
| 504         | Gateway Timeout       | Server Error | Upstream server timeout              |

## API Error Code categories

The Rampnow API uses standardized error codes to indicate the success or failure of requests. All error responses include a numeric code to help you identify and handle specific error conditions.

### Success Response

<ResponseField name="Success" type="number">
  **Code:** `0`

  Request completed successfully.
</ResponseField>

### Client Errors (100000-100019)

<AccordionGroup>
  <Accordion title="NotFoundErr - 100000">
    The requested resource could not be found. Verify the endpoint URL and resource ID.
  </Accordion>

  <Accordion title="NotAuthenticatedErr - 100001">
    Authentication credentials are missing or invalid. Check your API key and signature.
  </Accordion>

  <Accordion title="NotAuthorizedErr - 100002">
    You don't have permission to access this resource. Verify your account permissions.
  </Accordion>

  <Accordion title="InvalidArgsErr - 100004">
    One or more request parameters are invalid. Review the request payload and parameter requirements.
  </Accordion>

  <Accordion title="ConflictErr - 100005">
    The request conflicts with the current state of the resource. Check for duplicate operations.
  </Accordion>

  <Accordion title="ExpiredErr - 100014">
    The request or resource has expired. Generate a new request with updated timestamp.
  </Accordion>

  <Accordion title="InvalidErr - 100015">
    The request contains invalid data. Validate your input against the API specification.
  </Accordion>

  <Accordion title="MfaRequiredErr - 100016">
    Multi-factor authentication is required for this operation.
  </Accordion>

  <Accordion title="RequestErr - 100017">
    The request is malformed or contains errors. Review the request structure.
  </Accordion>

  <Accordion title="BlockedErr - 100018">
    Your account or IP has been blocked. Contact support for assistance.
  </Accordion>

  <Accordion title="BlacklistedErr - 100019">
    The resource or entity is blacklisted and cannot be processed.
  </Accordion>
</AccordionGroup>

### Operational Errors (100020-100023)

<AccordionGroup>
  <Accordion title="RetryExceededErr - 100020">
    Maximum retry attempts exceeded. Wait before retrying the operation.
  </Accordion>

  <Accordion title="NotSupportedErr - 100021">
    The requested operation or feature is not supported.
  </Accordion>

  <Accordion title="MfaSetupRequiredErr - 100022">
    Multi-factor authentication setup is required before proceeding.
  </Accordion>

  <Accordion title="InvalidQuoteErr - 100023">
    The quote provided is invalid or has expired. Request a new quote.
  </Accordion>
</AccordionGroup>

### Server Errors (100024-100032)

<AccordionGroup>
  <Accordion title="ServerErr - 100024">
    An internal server error occurred. Retry the request or contact support if the issue persists.
  </Accordion>

  <Accordion title="RequestTimeoutErr - 100025">
    The request timed out. Retry with a shorter payload or check your connection.
  </Accordion>

  <Accordion title="PayloadSizeErr - 100026">
    Request payload exceeds the maximum allowed size. Reduce the payload size.
  </Accordion>

  <Accordion title="RateLimitErr - 100027">
    Rate limit exceeded. Wait before making additional requests.
  </Accordion>

  <Accordion title="BadGatewayErr - 100028">
    Bad gateway error. The server received an invalid response from an upstream server.
  </Accordion>

  <Accordion title="ServiceUnavailableErr - 100029">
    Service is temporarily unavailable. Retry after some time.
  </Accordion>

  <Accordion title="GatewayTimeoutErr - 100030">
    Gateway timeout. The server did not receive a timely response from an upstream server.
  </Accordion>

  <Accordion title="InvalidMethodErr - 100031">
    HTTP method not allowed for this endpoint. Check the API documentation for allowed methods.
  </Accordion>

  <Accordion title="UnprocessableEntityErr - 100032">
    The request is well-formed but contains semantic errors. Validate your business logic.
  </Accordion>
</AccordionGroup>

### System Errors (100003, 100006-100013)

<AccordionGroup>
  <Accordion title="UnknownErr - 100003">
    An unknown error occurred. Contact support with your request details.
  </Accordion>

  <Accordion title="DbErr - 100006">
    Database error occurred. Retry the request or contact support.
  </Accordion>

  <Accordion title="MarshalErr - 100007">
    Error serializing or deserializing data. Check your request format.
  </Accordion>

  <Accordion title="InternalErr - 100008">
    Internal system error. Contact support if the issue persists.
  </Accordion>

  <Accordion title="HttpErr - 100009">
    HTTP communication error. Check your network connection and retry.
  </Accordion>

  <Accordion title="SetupErr - 100010">
    System setup or configuration error. Contact support.
  </Accordion>

  <Accordion title="NotImplementedErr - 100011">
    Feature not yet implemented. Check the API documentation for available features.
  </Accordion>

  <Accordion title="ExtApiErr - 100012">
    External API error. A third-party service encountered an issue.
  </Accordion>

  <Accordion title="TimeoutErr - 100013">
    Operation timed out. Retry the request.
  </Accordion>
</AccordionGroup>

## Quick Reference Table

| Code   | Error Name             | Category    | Description                                    |
| ------ | ---------------------- | ----------- | ---------------------------------------------- |
| 0      | Success                | Success     | Request completed successfully                 |
| 100000 | NotFoundErr            | Client      | Resource not found                             |
| 100001 | NotAuthenticatedErr    | Client      | Authentication failed                          |
| 100002 | NotAuthorizedErr       | Client      | Authorization failed                           |
| 100003 | UnknownErr             | System      | Unknown error                                  |
| 100004 | InvalidArgsErr         | Client      | Invalid arguments                              |
| 100005 | ConflictErr            | Client      | Resource conflict                              |
| 100006 | DbErr                  | System      | Database error                                 |
| 100007 | MarshalErr             | System      | Serialization error                            |
| 100008 | InternalErr            | System      | Internal error                                 |
| 100009 | HttpErr                | System      | HTTP error                                     |
| 100010 | SetupErr               | System      | Setup error                                    |
| 100011 | NotImplementedErr      | System      | Not implemented                                |
| 100012 | ExtApiErr              | System      | External API error                             |
| 100013 | TimeoutErr             | System      | Timeout error                                  |
| 100014 | ExpiredErr             | Client      | Resource expired                               |
| 100015 | InvalidErr             | Client      | Invalid data                                   |
| 100016 | MfaRequiredErr         | Client      | MFA required                                   |
| 100017 | RequestErr             | Client      | Request error                                  |
| 100018 | BlockedErr             | Client      | Account blocked                                |
| 100019 | BlacklistedErr         | Client      | Resource blacklisted                           |
| 100020 | RetryExceededErr       | Operational | Retry limit exceeded                           |
| 100021 | NotSupportedErr        | Operational | Not supported                                  |
| 100022 | MfaSetupRequiredErr    | Operational | MFA setup required                             |
| 100023 | InvalidQuoteErr        | Operational | Invalid quote                                  |
| 100024 | ServerErr              | Server      | Server error                                   |
| 100025 | RequestTimeoutErr      | Server      | Request timeout                                |
| 100026 | PayloadSizeErr         | Server      | Payload too large                              |
| 100027 | RateLimitErr           | Server      | Rate limit exceeded                            |
| 100028 | BadGatewayErr          | Server      | Bad gateway                                    |
| 100029 | ServiceUnavailableErr  | Server      | Service unavailable                            |
| 100030 | GatewayTimeoutErr      | Server      | Gateway timeout                                |
| 100031 | InvalidMethodErr       | Server      | Invalid HTTP method                            |
| 100032 | UnprocessableEntityErr | Server      | Unprocessable entity                           |
| 100033 | LowLiquidityErr        | Operational | Insufficient liquidity for the requested quote |

<Warning>
  Always implement proper error handling in your application. Log error codes and messages for debugging purposes.
</Warning>


# Hosted Mode Integration
Source: https://docs.rampnow.io/api-reference/hosted-mode

Complete control over user experience with minimal Rampnow branding

<Note>
  Hosted mode gives you full control over the user experience. Users stay on your platform throughout the entire flow.
</Note>

## Overview

Hosted mode allows you to integrate Rampnow's on-ramp and off-ramp services while maintaining complete control over the user interface. Unlike widget integration, users never leave your platform — you control the entire experience, with Rampnow handling only the payment steps when needed.

<div>
  <Card title="Seamless Experience" icon="sparkles">
    Keep users on your platform throughout the entire flow
  </Card>

  <Card title="Custom Branding" icon="palette">
    Minimal Rampnow branding, maximum control
  </Card>

  <Card title="Full UI Control" icon="sliders">
    Build your own interface using Rampnow's REST APIs
  </Card>
</div>

***

## Implementation Steps

<Steps>
  <Step title="Onboard User (optional)">
    <Note>
      This step is **optional**. Create Order (next step) accepts the same `user` object and onboards the customer automatically. Call Create Customer User up front only if you want to pre-register a customer or fetch their KYC status via the returned `uid` before creating an order.
    </Note>

    Use the [Create Customer User](/api-reference/users/createcustomeruser) endpoint. It returns a customer `uid` you can use with [Get Customer KYC](/api-reference/users/getcustomeruserkyc).

    ```bash cURL theme={null}
    curl --request POST \
      --url https://api.rampnow.io/api/partner/v1/ext/customer_user \
      --header 'Content-Type: application/json' \
      --header 'X-RAMPNOW-API-KEY: YOUR_API_KEY' \
      --header 'X-RAMPNOW-TIMESTAMP: UNIX_SECONDS' \
      --header 'X-RAMPNOW-SIGN: HMAC_SHA256_SIGNATURE' \
      --data '{
        "userDetail": {
          "firstName": "John",
          "lastName": "Doe",
          "email": "john@example.com",
          "phone": "+491234567890",
          "dateOfBirth": "1990-01-15",
          "gender": "male",
          "country": "DE",
          "address": {
            "line1": "123 Main St",
            "city": "Berlin",
            "postalCode": "10115",
            "country": "DE"
          }
        }
      }'
    ```

    ### Key fields

    | Field                               | Required | Description                                       |
    | ----------------------------------- | -------- | ------------------------------------------------- |
    | `userDetail.firstName` / `lastName` | Required | User's name                                       |
    | `userDetail.email`                  | Required | User's email address                              |
    | `userDetail.phone`                  | Required | Phone number with country code                    |
    | `userDetail.dateOfBirth`            | Required | Date of birth in `YYYY-MM-DD` format              |
    | `userDetail.gender`                 | Required | `male`, `female` or `unknown`                     |
    | `userDetail.country`                | Required | ISO 3166-1 alpha-2 country code (e.g. `DE`, `US`) |
    | `userDetail.address`                | Optional | User's residential address                        |
  </Step>

  <Step title="Create Order">
    Create an order using the [Create Hosted Order](/api-reference/onoff-ramp-orders/createcheckoutorder) endpoint. The response includes a `redirectUrl` — send the user there to complete payment (and any KYC) on Rampnow's hosted screens.

    ```bash cURL theme={null}
    curl --request POST \
      --url https://api.rampnow.io/api/partner/v1/ext/ramp_order/checkout \
      --header 'Content-Type: application/json' \
      --header 'X-RAMPNOW-API-KEY: YOUR_API_KEY' \
      --header 'X-RAMPNOW-TIMESTAMP: UNIX_SECONDS' \
      --header 'X-RAMPNOW-SIGN: HMAC_SHA256_SIGNATURE' \
      --data '{
        "orderType": "buy",
        "externalOrderUid": "your-unique-order-id",
        "srcCurrency": "EUR",
        "srcChain": "fiat",
        "srcAmount": "250",
        "dstCurrency": "ETH",
        "dstChain": "ethereum",
        "user": {
          "firstName": "John",
          "lastName": "Doe",
          "email": "john@example.com",
          "phone": "+491234567890",
          "dateOfBirth": "1990-01-15",
          "gender": "male",
          "country": "DE"
        },
        "wallet": {
          "address": "0xUserDestinationWalletAddress",
          "custodyType": "unhosted"
        }
      }'
    ```

    ### Key fields

    | Field                      | Required | Description                                                                                      |
    | -------------------------- | -------- | ------------------------------------------------------------------------------------------------ |
    | `orderType`                | Required | `buy` (onramp) or `sell` (offramp)                                                               |
    | `externalOrderUid`         | Required | Your unique order id — used later to look the order up                                           |
    | `srcCurrency` / `srcChain` | Required | What the user pays with. For an onramp: fiat currency (e.g. `EUR`) on chain `fiat`               |
    | `srcAmount`                | Required | Amount in `srcCurrency`                                                                          |
    | `dstCurrency` / `dstChain` | Optional | Crypto asset + network to deliver (e.g. `ETH` on `ethereum`)                                     |
    | `user`                     | Required | Customer details — `firstName`, `lastName`, `email`, `phone`, `dateOfBirth`, `gender`, `country` |
    | `wallet`                   | Optional | Destination wallet `{ address, custodyType }` (`custodyType`: `unhosted` or `hosted`)            |

    The response returns `orderUid`, `userUid` and a `redirectUrl`. Redirect the user to `redirectUrl`; track the outcome via webhooks (below) or by polling the order (see [Track order status](#track-order-status)).
  </Step>

  <Step title="Set Up Webhooks (Optional)">
    Track transaction status in real-time by configuring webhooks in your **Rampnow Partner Dashboard**.

    <Tip>
      Webhook setup documentation is available in our [Webhook Guide](/api-reference/webhook).
    </Tip>
  </Step>
</Steps>

***

## Integration Flow

```mermaid theme={null}
sequenceDiagram
    participant User
    participant Partner as Your Platform
    participant Rampnow as Rampnow API

    User->>Partner: Initiates buy/sell
    Partner->>Rampnow: Create Customer User
    Rampnow-->>Partner: User onboarded
    Partner->>Rampnow: Create Hosted Order
    Rampnow-->>Partner: Order + payment details
    Partner->>User: Display payment instructions
    User->>Partner: Completes payment
    Rampnow-->>Partner: Webhook notification (order status)
    Partner->>User: Confirm transaction
```

***

## Support & Config Endpoints

Instead of probing `asset_config` pair-by-pair, use these bulk endpoints to discover what is live:

| Endpoint                                                | Returns                                                                                                                                      |
| ------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `GET /api/partner/v1/ext/ramp_order/config`             | Full support matrix in one call: every configured asset, payment mode and order type, split by direction (`buy` = onramp, `sell` = offramp). |
| `GET /api/partner/v1/ext/ramp_order/blocked_currencies` | Supported countries with the crypto currencies blocked in each. Pass `?country=<ISO alpha-2>` to filter to one country.                      |

Both are HMAC-authenticated like the rest of the external API.

***

## Partner Fee (Markup)

To take a margin on an order, pass your fee on the quote and order-creation requests. Both fields are optional and **override** the fee configured on your account for that request:

| Field             | Type   | Description                                                         |
| ----------------- | ------ | ------------------------------------------------------------------- |
| `partnerPctFee`   | number | Partner fee as a percentage of the order amount (e.g. `1.5` = 1.5%) |
| `partnerFixedFee` | number | Fixed partner fee in the order's base currency                      |

They apply to the quote (`/ext/ramp_order/quote`) and the checkout order (`/ext/ramp_order/checkout`). When omitted, the account-configured partner fee applies. The resolved partner amount is returned as a separate `partner` entry in `feeDetails` on the **order** responses — `GET /ext/ramp_order/{uid}` and the webhook — so you can reconcile it (see below). It is **not** broken out in the quote, where it stays folded into the `platform` line.

Add either field to the Create Order body from the previous step, e.g.:

```json theme={null}
{
  "orderType": "buy",
  "externalOrderUid": "your-unique-order-id",
  "srcCurrency": "EUR",
  "srcChain": "fiat",
  "srcAmount": "250",
  "dstCurrency": "ETH",
  "dstChain": "ethereum",
  "user": { "firstName": "John", "lastName": "Doe", "email": "john@example.com", "phone": "+491234567890", "dateOfBirth": "1990-01-15", "gender": "male", "country": "DE" },
  "wallet": { "address": "0xUserDestinationWalletAddress", "custodyType": "unhosted" },
  "partnerPctFee": 1.5
}
```

***

## Fee Breakdown (`feeDetails`)

Quote and order responses return a `feeDetails` array. Each entry has a `type`, `fee`, `currency`, and `isInclusive`. The returned `type` values are:

| `type`     | Description                                                                                   | Where                                              |
| ---------- | --------------------------------------------------------------------------------------------- | -------------------------------------------------- |
| `platform` | Aggregated platform fee (Rampnow service + processing, and — in the quote — your partner fee) | quote + order                                      |
| `network`  | Blockchain network (gas) fee                                                                  | quote + order                                      |
| `partner`  | Your partner fee / markup, broken out as its own line                                         | order only (`GET /ext/ramp_order/{uid}` + webhook) |

**Reconciliation.** In the quote, the partner fee is folded into `platform`, so `total = platform + network`. On the order responses it is broken out: `platform` **excludes** the partner amount and a `partner` line is added, so `total = platform + network + partner` — the total is identical either way.

***

## Track order status

You receive a webhook on every order status change (recommended — see [Webhooks](/api-reference/webhook)). To poll instead, use [Get Order](/api-reference/onoff-ramp-orders/getramporderbyexternaluid):

```bash cURL theme={null}
curl --request GET \
  --url https://api.rampnow.io/api/partner/v1/ext/ramp_order/your-unique-order-id \
  --header 'X-RAMPNOW-API-KEY: YOUR_API_KEY' \
  --header 'X-RAMPNOW-TIMESTAMP: UNIX_SECONDS' \
  --header 'X-RAMPNOW-SIGN: HMAC_SHA256_SIGNATURE'
```

* The path parameter is **your** `externalOrderUid` (the id you sent on Create Order), not Rampnow's `orderUid`.
* The response is an **array** — `orderList` — of orders matching that external id (normally one). Read `status` (and `paymentStatus`) from the entry; the full list of statuses and their meaning is in the [webhook status table](/api-reference/webhook).

## When to Use Hosted Mode

<AccordionGroup>
  <Accordion title="Ideal For" icon="check">
    * Platforms requiring a fully custom user experience
    * Teams wanting minimal Rampnow branding
    * Applications needing full UI control over every step
  </Accordion>

  <Accordion title="Considerations" icon="triangle-exclamation">
    * Requires custom UI development on your end
    * Integration takes longer than widget mode or the SDK
    * You manage the user flow and error handling
  </Accordion>
</AccordionGroup>

***

## Next Steps

<div>
  <Card title="Create Customer User" icon="user-check" href="/api-reference/users/createcustomeruser">
    Onboard users with the Create Customer User endpoint
  </Card>

  <Card title="Create Order" icon="cart-shopping" href="/api-reference/onoff-ramp-orders/createcheckoutorder">
    Create hosted orders via the API
  </Card>

  <Card title="Webhooks" icon="bell" href="/api-reference/webhook">
    Set up real-time transaction status notifications
  </Card>

  <Card title="Rampnow SDK" icon="cube" href="/api-reference/sdk">
    Prefer a quicker integration? Try the SDK with built-in event handling
  </Card>
</div>


# CreateCheckoutOrder
Source: https://docs.rampnow.io/api-reference/onoff-ramp-orders/createcheckoutorder

/api-reference/partner_external.yaml post /api/partner/v1/ext/ramp_order/checkout



# GetRampOrderByExternalUid
Source: https://docs.rampnow.io/api-reference/onoff-ramp-orders/getramporderbyexternaluid

/api-reference/partner_external.yaml get /api/partner/v1/ext/ramp_order/{uid}



# GetRampOrderQuote
Source: https://docs.rampnow.io/api-reference/onoff-ramp-orders/getramporderquote

/api-reference/partner_external.yaml post /api/partner/v1/ext/ramp_order/quote



# Overview
Source: https://docs.rampnow.io/api-reference/overview

Basics of Rampnow API

## Getting Started

<Steps>
  <Step title="Start with Sandbox">
    Begin your integration using the Sandbox environment at `api.sandbox.rampnow.io`. This allows you to test without affecting real data.
  </Step>

  <Step title="Test thoroughly">
    Verify all API endpoints, error handling and edge cases work as expected in Sandbox.
  </Step>

  <Step title="Request Production access">
    Once testing is complete and your integration is stable, request Production access.
  </Step>

  <Step title="Deploy to Production">
    Switch your base URL to `api.rampnow.io` and go live with confidence.
  </Step>
</Steps>

## Open API documentation

Our OpenAPI documentation: [OpenAPI](https://rampnow-io.github.io/core/partner_external.yaml). For the starter kit, we are using the following OpenAPI specification.

<Card title="Rampnow OpenAPI" icon="leaf" href="https://rampnow-io.github.io/core/partner_external.yaml">
  View the OpenAPI specification file
</Card>

## API Environments

Rampnow provides two separate environments to support your development and production workflows:

<div>
  <Card title="Production" icon="globe">
    `https://api.rampnow.io`

    Live environment for production applications with real transactions.
  </Card>

  <Card title="Sandbox" icon="flask">
    `https://api.sandbox.rampnow.io`

    Testing environment for development and integration testing.
  </Card>
</div>

### Environment Comparison

| Feature      | Sandbox                 | Production        |
| ------------ | ----------------------- | ----------------- |
| Base URL     | api.sandbox.rampnow\.io | api.rampnow\.io   |
| Purpose      | Testing & Development   | Live Transactions |
| Data         | Test data only          | Real data         |
| Access       | Immediate               | Requires approval |
| Transactions | Simulated               | Real              |

<Note> Both environments use the same API structure and authentication methods. Simply change the base URL when moving from Sandbox to Production. </Note>

<Warning>
  You must thoroughly test your integration in Sandbox mode before requesting access to Production. Production access is granted only after successful integration testing.
</Warning>

## API Versioning

<Info>
  The Rampnow API follows a stable versioning policy to ensure your integrations remain functional.
</Info>

### Our Versioning Promise

**Breaking Changes**

* All incompatible or breaking changes are versioned
* Existing endpoints will continue to work without modification
* You control when to migrate to new API versions

**Non-Breaking Changes**

* New fields may be added to JSON responses at any time
* New optional parameters may be introduced
* New endpoints may be added

<Warning>
  **Important:** We may add additional fields to JSON responses without notice or version changes. Ensure your code can handle unknown properties gracefully.
</Warning>

## Response Format

All API responses return JSON payloads with a consistent structure:

### Success Response

Every response is wrapped in `{ code, message, traceId, data }` (`data` holds the endpoint's payload; `code` `0` = success).

```JSON JSON theme={null}
{
  "code": 0,
  "message": "success",
  "traceId": "b1f2c3d4-...",
  "data": {
    "orderUid": "5de57551-3272-4af5-86a4-5eeae6ccc37f",
    "status": "completed"
  }
}
```

### Error Response

```JSON JSON theme={null}
{
  "code": 100004,
  "message": "invalid_args_err",
  "displayError": "Amount is below the minimum for this route.",
  "traceId": "b1f2c3d4-..."
}
```

<Note>
  Rely on **`code`** to branch your logic, not on the message text.

  * **`message`** is a stable, generic label for the error `code` (e.g. `invalid_args_err`). It never contains internal or upstream-provider error detail.
  * **`displayError`** is an optional, human-readable message safe to show to your end user (e.g. "Amount is below the minimum for this route."). It is present only when a user-facing message applies; fall back to your own copy keyed on `code` when it is absent.
  * **`traceId`** identifies the request in our logs — include it when contacting support.
</Note>

## Key Features

<AccordionGroup> <Accordion title="RESTful Architecture" icon="arrows-rotate"> Built on REST principles with predictable resource-oriented URLs and standard HTTP methods. </Accordion> <Accordion title="JSON Responses" icon="brackets-curly"> All responses are returned in JSON format for easy parsing and integration. </Accordion> <Accordion title="HTTPS Only" icon="lock"> All API requests must be made over HTTPS. Plain HTTP requests are rejected for security. </Accordion> <Accordion title="HMAC Authentication" icon="key"> Secure request signing using HMAC-SHA256 ensures request authenticity and integrity. </Accordion> <Accordion title="Comprehensive Error Codes" icon="circle-exclamation"> Detailed error codes and messages help you quickly identify and resolve issues. </Accordion> </AccordionGroup>

## Next Steps

Ready to start building? Here's what to do next:

<div>
  <Card title="Authentication" icon="shield-halved" href="/api-reference/authentication">
    Learn how to authenticate your API requests
  </Card>

  <Card title="Error Codes" icon="list-check" href="/api-reference/error-codes">
    Understand error codes and how to handle them
  </Card>

  <Card title="API Endpoints" icon="code" href="/api-reference/users/createcustomeruser">
    Explore available API endpoints
  </Card>
</div>


# Postman Collection
Source: https://docs.rampnow.io/api-reference/postman-collection

Explore and test Rampnow API with Postman

## Overview

Postman is an application designed to help with API integration and exploration. Intuitive for different tech skill levels, it's the tool of choice for both experienced developers and those new to APIs to get familiar with available endpoints, requests, and responses.

Using our Rampnow Postman Collection, you can start testing our API before you write a single line of code. Explore endpoints, understand request/response structures, and validate your integration setup in an interactive environment.

<Note>
  The Postman collection includes pre-configured requests for all major Rampnow API endpoints with built-in authentication headers and sample payloads.
</Note>

## Getting Started with Postman

### Prerequisites

Before importing the Rampnow collection, ensure you have:

* A Rampnow Partner Dashboard account
* Your API Key and Secret Key generated from the Dashboard
* Either the Postman desktop app or Postman web version

### Install Postman

1. **Download and install** the [Postman app](https://www.postman.com/downloads/) or use [Postman online](https://www.postman.com/product/rest-client/)

2. **Create or sign into** your Postman account

### Import the Rampnow Collection

<Steps>
  <Step title="Get the collection link">
    Copy the Rampnow Postman collection link from [here](https://rampnow-io.github.io/core/partner_external-postman.json).
  </Step>

  <Step title="Import into Postman">
    Click the "Run in Postman" button or manually import by:

    * Opening Postman
    * Going to **File** → **Import**
    * Pasting the collection link or uploading the JSON file
  </Step>

  <Step title="Set up environment variables">
    Create or import the Rampnow environment and configure:

    * `api_key`: Your API Key from the Partner Dashboard
    * `api_secret`: Your Secret Key from the Partner Dashboard
    * `base_url`: The API base URL (sandbox or production)
  </Step>

  <Step title="Start exploring">
    Browse the collection folders to explore different API endpoints and test requests
  </Step>
</Steps>

## What's Included

The Rampnow Postman collection includes:

<div>
  <Card title="Authentication" icon="key">
    Pre-configured request signing with HMAC-SHA256 authentication headers
  </Card>

  <Card title="Onramp Endpoints" icon="arrow-down">
    Complete set of onramp API requests for currency conversions and payments
  </Card>

  <Card title="Offramp Endpoints" icon="arrow-up">
    Offramp API requests for converting crypto back to fiat currencies
  </Card>

  <Card title="Quote Requests" icon="quote">
    Real-time pricing and quote endpoints for both onramp and offramp flows
  </Card>

  <Card title="Order Management" icon="list-check">
    Endpoints for creating, updating, and tracking orders
  </Card>

  <Card title="Sample Payloads" icon="code">
    Pre-filled request bodies demonstrating proper payload formatting
  </Card>
</div>

## Using the Collection

### Making Your First Request

1. Select an endpoint from the collection
2. Review the request details (method, URL, headers)
3. Modify the path or query parameters as needed
4. Click **Send** to execute the request
5. View the response in the response panel

### Testing Different Environments

The collection supports both Sandbox and Production environments:

* Switch between environments using the environment selector dropdown
* Sandbox requests go to `https://api.sandbox.rampnow.io`
* Production requests go to `https://api.rampnow.io`

<Warning>
  Always test your integration thoroughly in the Sandbox environment before switching to Production.
</Warning>

## Collection Structure

The collection is organized into folders by functionality:

| Folder                     | Purpose                                   |
| -------------------------- | ----------------------------------------- |
| **Authentication**         | Authentication setup and signing examples |
| **Sandbox Environment**    | Sandbox-specific requests and test data   |
| **Production Environment** | Production API requests                   |
| **Quotes**                 | Quote and pricing endpoints               |
| **Orders**                 | Order creation and management endpoints   |
| **Settlement**             | Settlement and transaction endpoints      |

## Postman Collection

<Card title="Rampnow API Collection" icon="mail" href="https://rampnow-io.github.io/core/partner_external-postman.json">
  Import the Rampnow Postman collection to try the partner API with your keys.
</Card>

## Next Steps

* Review the [Authentication](./authentication.mdx) guide to understand request signing
* Explore the [API Reference](./overview.mdx) for detailed endpoint documentation
* Test with sample payloads in the Sandbox environment
* Review [Error Codes](./error-codes.mdx) for handling API responses

## Tips & Best Practices

* **Use variables** for frequently changed values (API keys, amounts, addresses)
* **Create custom scripts** in the Pre-request tab to automate timestamp and signature generation
* **Save responses** to keep track of successful requests
* **Use collections** to organize requests by workflow
* **Export results** for documentation and troubleshooting

<Info>
  Need help? Check out the [Postman documentation](https://learning.postman.com/) or contact our support team for assistance with integration.
</Info>


# Quick Start
Source: https://docs.rampnow.io/api-reference/quickstart

Get started with Rampnow integration in minutes

<Note>
  Welcome to the Rampnow Quick Start Guide! This guide will walk you through integrating Rampnow's on-ramp and off-ramp services into your platform.
</Note>

## Choose Your Integration Method

Rampnow offers three powerful integration options to seamlessly add cryptocurrency on/off-ramp services to your platform:

<div>
  <Card title="Hosted Mode Integration" icon="browser" href="#hosted-mode-integration">
    Take full control of the user journey. The entire on/off ramp experience is managed by you, giving you complete customization and branding control.
  </Card>

  <Card title="Widget Mode Integration" icon="window" href="#widget-mode-integration">
    Embed Rampnow's on/off ramp directly into your application for a seamless, plug-and-play user experience with minimal setup.
  </Card>

  <Card title="Rampnow SDK" icon="cube" href="#rampnow-sdk">
    Install the `@rampnow/sdk` npm package for a developer-friendly integration with TypeScript support, event handling, and a React hook.
  </Card>
</div>

These integration methods ensure your users can buy and sell cryptocurrencies effortlessly, with access to multiple payment options and supported assets.

## Hosted Mode Integration

<Info>
  In hosted mode, you control the entire user journey through the on/off ramp process. This gives you maximum flexibility for customization and branding.
</Info>

### What is Hosted Mode?

Hosted mode allows you to integrate Rampnow's services while maintaining complete control over the user interface and experience. Your users interact with your platform throughout the entire transaction flow.

### Key Features

<AccordionGroup>
  <Accordion title="Full Customization" icon="palette">
    Design and customize every aspect of the user interface to match your brand identity and user experience standards.
  </Accordion>

  <Accordion title="Complete Control" icon="sliders">
    Manage the entire transaction flow, from initiation to completion, within your own application environment.
  </Accordion>

  <Accordion title="Flexible Integration" icon="puzzle-piece">
    Integrate Rampnow's API endpoints directly into your backend systems for maximum flexibility.
  </Accordion>
</AccordionGroup>

### Getting Started with Hosted Mode

<Steps>
  <Step title="Obtain API Credentials">
    Contact our sales team or log into the Partner Dashboard to generate your API keys and secret.
  </Step>

  <Step title="Set Up Authentication">
    Implement the authentication flow using your API credentials. See our [Authentication Guide](/api-reference/authentication) for details.
  </Step>

  <Step title="Integrate API Endpoints">
    Use our API endpoints to create quotes, initiate orders and track transaction status.
  </Step>

  <Step title="Build Your UI">
    Design and implement your custom user interface that calls our API endpoints.
  </Step>

  <Step title="Test in Sandbox">
    Thoroughly test your integration in our Sandbox environment before going live.
  </Step>
</Steps>

<Card title="View Hosted Mode Documentation" icon="book" href="/api-reference/hosted-mode">
  Explore detailed documentation for Hosted Mode integration
</Card>

***

## Widget Mode Integration

<Info>
  Widget mode provides a pre-built, embeddable solution that you can add to your application with minimal code. Perfect for quick integration.
</Info>

### What is Widget Mode?

Widget mode offers a ready-to-use interface that you can embed directly into your application. Rampnow handles the UI and transaction flow while you maintain control over when and where the widget appears.

### Key Features

<AccordionGroup>
  <Accordion title="Quick Setup" icon="bolt">
    Get up and running in minutes with just a few lines of code. No complex backend integration required.
  </Accordion>

  <Accordion title="Pre-Built UI" icon="window-maximize">
    Use our professionally designed, mobile-responsive interface that's ready to go out of the box.
  </Accordion>

  <Accordion title="Automatic Updates" icon="arrows-rotate">
    Benefit from automatic updates and improvements to the widget without any code changes on your end.
  </Accordion>

  <Accordion title="Customizable Appearance" icon="paintbrush">
    Customize colors, themes and branding to match your application's look and feel.
  </Accordion>
</AccordionGroup>

### Getting Started with Widget Mode

<Steps>
  <Step title="Get Your App Key">
    Obtain your unique App key from the Partner Dashboard.
  </Step>

  <Step title="Set Up the Container">
    Define a container element in your HTML where the widget will be embedded.

    ```html theme={null}
    <div id="ramp-container"></div>
    ```
  </Step>

  <Step title="Create the Rampnow URL">
    Here’s an example of a full URL with all the parameters.

    ```html theme={null}
    https://app.rampnow.io/order/quote?apiKey=YOUR_API_KEY&srcCurrency=EUR&srcAmount=250&dstCurrency=BTC&dstChain=bitcoin&walletAddress=0xYourWalletAddress
    ```
  </Step>

  <Step title="Initialize the Widget">
    Initialize widget by passing the constructed Rampnow widget URL as below.

    ```html theme={null}
    <iframe src="https://app.rampnow.io/order/quote?apiKey=YOUR_API_KEY&srcCurrency=EUR&srcAmount=250&dstCurrency=BTC&dstChain=bitcoin&walletAddress=0xYourWalletAddress" title="On Ramp"></iframe>
    ```
  </Step>
</Steps>

<Card title="View Widget Mode Documentation" icon="book" href="/api-reference/widget-mode">
  Explore detailed documentation for Widget Mode integration
</Card>

***

## Rampnow SDK

<Info>
  The Rampnow SDK is the recommended way to integrate the widget with full programmatic control, event handling, and TypeScript support.
</Info>

### What is the Rampnow SDK?

The [`@rampnow/sdk`](https://www.npmjs.com/package/@rampnow/sdk) package wraps the widget integration into a developer-friendly JavaScript/TypeScript SDK. It supports overlay, embedded, and redirect modes, and ships with a React hook for seamless use in React applications.

### Quick Example

```javascript theme={null}
import { RampnowSdk, RampnowEventType } from '@rampnow/sdk'

const sdk = new RampnowSdk({
  apiKey: 'pk_live_YOUR_API_KEY',
  srcCurrency: 'EUR',
  dstCurrency: 'ETH',
  walletAddress: '0xYourWalletAddress',
})

sdk
  .on(RampnowEventType.ORDER_COMPLETED, (e) => {
    console.log('Order completed:', e.payload.orderUid)
  })
  .init()
```

### Key Features

<AccordionGroup>
  <Accordion title="Multiple Integration Modes" icon="layer-group">
    Choose between **Overlay** (full-screen modal), **Embedded** (inline in your layout), or **Redirect** (URL for native apps and email links).
  </Accordion>

  <Accordion title="Event-Driven Architecture" icon="bell">
    Subscribe to 13+ lifecycle events — order creation, payment status, errors, and more.
  </Accordion>

  <Accordion title="React Hook" icon="react">
    Use `useRampnowSdk` for idiomatic React integration with minimal boilerplate.
  </Accordion>

  <Accordion title="TypeScript Support" icon="code">
    Full type definitions included out of the box for type-safe configuration and event handling.
  </Accordion>
</AccordionGroup>

<Tip>
  Try the SDK live at [demo.rampnow.io](https://demo.rampnow.io/).
</Tip>

<Card title="View SDK Documentation" icon="book" href="/api-reference/sdk">
  Explore the full SDK reference — installation, configuration, events, and React integration
</Card>

***

## What's Next?

<div>
  <Card title="API Reference" icon="code" href="/api-reference/users/createcustomeruser">
    Explore our complete API documentation with endpoints, parameters and examples
  </Card>

  <Card title="Authentication" icon="key" href="/api-reference/authentication">
    Learn how to securely authenticate your API requests
  </Card>

  <Card title="Supported Assets" icon="coins" href="/quickstart/resources/supported-assets">
    View the complete list of supported cryptocurrencies and fiat currencies
  </Card>

  <Card title="Contact Sales" icon="headset" href="https://rampnow.io/en/list#list-token-form">
    Have questions? Our team is here to help you get started
  </Card>
</div>

<Note>
  Need help? Contact our support team at [support@rampnow.io](mailto:support@rampnow.io) or visit our [Help Center](https://support.rampnow.io/portal/en/home).
</Note>


# Rampnow SDK
Source: https://docs.rampnow.io/api-reference/sdk

JavaScript/TypeScript SDK for embedding the Rampnow onramp and offramp widget into any website or web app

<Note>
  The Rampnow SDK provides a developer-friendly wrapper around the widget integration, with full TypeScript support, event handling, and a React hook.
</Note>

## Overview

The `@rampnow/sdk` package lets you embed Rampnow's onramp/offramp widget into your application with just a few lines of code. It supports three integration modes and ships with TypeScript definitions out of the box.

<div>
  <Card title="Overlay Mode" icon="layer-group">
    Full-screen modal overlay — quickest setup, no container needed
  </Card>

  <Card title="Embedded Mode" icon="window">
    Mount the widget inside any DOM element in your layout
  </Card>

  <Card title="Redirect Mode" icon="arrow-up-right-from-square">
    Generate a URL to open in a new tab — ideal for native apps or email links
  </Card>

  <Card title="React Hook" icon="react">
    First-class React support via `useRampnowSdk`
  </Card>
</div>

<Tip>
  Try the SDK live at [demo.rampnow.io](https://demo.rampnow.io/).
</Tip>

***

## Installation

<CodeGroup>
  ```bash npm theme={null}
  npm install @rampnow/sdk
  ```

  ```bash yarn theme={null}
  yarn add @rampnow/sdk
  ```

  ```bash pnpm theme={null}
  pnpm add @rampnow/sdk
  ```
</CodeGroup>

**CDN (no bundler):**

```html theme={null}
<script src="https://cdn.jsdelivr.net/npm/@rampnow/sdk/dist/rampnow-sdk.umd.js"></script>
```

When loaded via CDN, the SDK is available as `window.RampnowSdk`.

***

## Quick Start

<Steps>
  <Step title="Get your API key">
    Obtain your public API key from the [Rampnow Partner Dashboard](https://partner.rampnow.io) under **API Hub**. Keys are prefixed with `pk_live_...`.
  </Step>

  <Step title="Initialize the SDK">
    ```javascript theme={null}
    import { RampnowSdk, RampnowEventType } from '@rampnow/sdk'

    const sdk = new RampnowSdk({
      apiKey: 'pk_live_YOUR_API_KEY',
      orderType: 'buy',
      srcCurrency: 'EUR',
      dstCurrency: 'ETH',
      dstChain: 'ethereum',
    })
    ```
  </Step>

  <Step title="Open the widget">
    ```javascript theme={null}
    sdk.init()
    ```
  </Step>

  <Step title="Listen for events">
    ```javascript theme={null}
    sdk.on(RampnowEventType.ORDER_COMPLETED, (e) => {
      console.log('Order completed:', e.payload.orderUid)
    })
    ```
  </Step>
</Steps>

***

## Configuration

Pass a config object when creating a new `RampnowSdk` instance:

| Option             | Type               | Default                  | Description                                        |
| ------------------ | ------------------ | ------------------------ | -------------------------------------------------- |
| `apiKey`           | `string`           | **required**             | Partner public API key                             |
| `widgetUrl`        | `string`           | `https://app.rampnow.io` | Override the widget base URL                       |
| `containerId`      | `string`           | —                        | DOM element ID for embedded mode; omit for overlay |
| `width`            | `string \| number` | `450`                    | Iframe width (px)                                  |
| `height`           | `string \| number` | `700`                    | Iframe height (px)                                 |
| `orderType`        | `'buy' \| 'sell'`  | —                        | Pre-select order direction                         |
| `srcCurrency`      | `string`           | —                        | Source currency, e.g. `'EUR'`, `'USD'`             |
| `srcChain`         | `string`           | —                        | Source chain                                       |
| `dstCurrency`      | `string`           | —                        | Destination currency, e.g. `'ETH'`, `'BTC'`        |
| `dstChain`         | `string`           | —                        | Destination chain, e.g. `'ethereum'`, `'bitcoin'`  |
| `paymentMode`      | `string`           | —                        | Payment method, e.g. `'sepa'`, `'ach'`             |
| `srcAmount`        | `string`           | —                        | Pre-fill source amount                             |
| `walletAddress`    | `string`           | —                        | Pre-fill recipient wallet address                  |
| `walletAddressTag` | `string`           | —                        | Wallet memo/tag (for XRP, XLM, etc.)               |
| `externalOrderId`  | `string`           | —                        | Your own order ID for cross-referencing            |
| `utm_source`       | `string`           | —                        | UTM tracking                                       |
| `utm_medium`       | `string`           | —                        | UTM tracking                                       |
| `utm_campaign`     | `string`           | —                        | UTM tracking                                       |

***

## Integration Modes

### Overlay Mode (Default)

Opens the widget as a full-screen modal overlay. No container element needed.

```javascript theme={null}
import { RampnowSdk } from '@rampnow/sdk'

const sdk = new RampnowSdk({
  apiKey: 'pk_live_YOUR_API_KEY',
  orderType: 'buy',
  srcCurrency: 'EUR',
  dstCurrency: 'ETH',
  dstChain: 'ethereum',
})

sdk.init() // Opens the overlay
```

### Embedded Mode

Mount the widget inside a specific DOM element by providing a `containerId`.

```html theme={null}
<div id="rampnow-widget"></div>
```

```javascript theme={null}
import { RampnowSdk } from '@rampnow/sdk'

const sdk = new RampnowSdk({
  apiKey: 'pk_live_YOUR_API_KEY',
  containerId: 'rampnow-widget',
  width: 450,
  height: 700,
  orderType: 'buy',
  dstCurrency: 'ETH',
  dstChain: 'ethereum',
})

sdk.init()
```

### Redirect Mode

Generate a widget URL without opening an iframe — useful for native apps, email links, or server-side flows.

```javascript theme={null}
import { RampnowSdk } from '@rampnow/sdk'

const url = RampnowSdk.createRedirectUrl({
  apiKey: 'pk_live_YOUR_API_KEY',
  orderType: 'buy',
  srcCurrency: 'EUR',
  srcAmount: '250',
  dstCurrency: 'BTC',
  dstChain: 'bitcoin',
  walletAddress: '0xYourWalletAddress',
})

window.open(url, '_blank')
```

***

## React Integration

The SDK ships with a React hook for seamless integration in React applications.

<Info>
  React (`>=18`) and ReactDOM (`>=18`) are optional peer dependencies — only required when using the hook.
</Info>

```tsx theme={null}
import { useRampnowSdk } from '@rampnow/sdk/react'
import { RampnowCommandType, RampnowEventType } from '@rampnow/sdk'
import { useEffect } from 'react'

function BuyCryptoButton() {
  const { init, close, send, on, isOpen } = useRampnowSdk({
    apiKey: 'pk_live_YOUR_API_KEY',
    srcCurrency: 'EUR',
    dstCurrency: 'ETH',
  })

  useEffect(() => {
    on(RampnowEventType.ORDER_COMPLETED, (e) => {
      console.log('Completed:', e.payload.orderUid)
      close()
    })
  }, [on, close])

  return <button onClick={init}>{isOpen ? 'Loading…' : 'Buy Crypto'}</button>
}
```

***

## API Reference

### `new RampnowSdk(config)`

Creates an SDK instance. Validates the `apiKey` and merges defaults. Does **not** open the widget — call `.init()` to display it.

### `sdk.init(): RampnowSdk`

Opens the widget. If `containerId` is set, mounts the iframe in that element; otherwise creates a full-screen overlay. Returns `this` for chaining.

### `sdk.close(): void`

Closes and removes the widget from the DOM.

### `sdk.on(eventType, callback): RampnowSdk`

Subscribe to widget events. Returns `this` for chaining.

```javascript theme={null}
// Single event
sdk.on(RampnowEventType.ORDER_CREATED, callback)

// Multiple events
sdk.on([RampnowEventType.ORDER_CREATED, RampnowEventType.ORDER_COMPLETED], callback)

// All events
sdk.on('*', callback)
```

### `sdk.off(eventType, callback): RampnowSdk`

Unsubscribe from events. Same forms as `.on()`.

### `sdk.send(commandType, payload): RampnowSdk`

Send a command to the widget iframe. Returns `this` for chaining. See [Commands](#commands) for available command types.

```javascript theme={null}
import { RampnowCommandType } from '@rampnow/sdk'

sdk.send(RampnowCommandType.UPDATE_PAYMENT_DETAIL, {
  transactionHash: '0xabc123...',
})
```

### `sdk.isOpen: boolean`

Read-only property indicating whether the widget is currently displayed.

### `RampnowSdk.createRedirectUrl(config): string` (static)

Builds a full widget URL from config without opening any iframe. Returns a URL string.

***

## Events

Subscribe to events using `sdk.on()` with the `RampnowEventType` enum:

| Event                      | Payload                                                                                                                                                    | Description                        |
| -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------- |
| `WIDGET_READY`             | —                                                                                                                                                          | Widget iframe loaded and ready     |
| `WIDGET_CLOSED`            | —                                                                                                                                                          | Widget was closed                  |
| `USER_AUTHENTICATED`       | —                                                                                                                                                          | User signed in                     |
| `ORDER_CREATED`            | `orderUid`, `orderType`, `srcCurrency`, `srcChain`, `srcAmount`, `dstCurrency`, `dstChain`, `paymentMode`, `cryptoTxnInfo?`, `bankTxnInfo?`                | Order successfully created         |
| `ORDER_PAYMENT_PROCESSING` | `orderUid`, `status`, `paymentStatus`                                                                                                                      | Payment is being processed         |
| `ORDER_PAYMENT_COMPLETED`  | `orderUid`, `status`, `paymentStatus`                                                                                                                      | Payment received by Rampnow        |
| `ORDER_PAYMENT_FAILED`     | `orderUid`, `status`, `paymentStatus`                                                                                                                      | Payment failed                     |
| `ORDER_COMPLETED`          | `orderUid`, `status`, `srcCurrency`, `srcChain`, `srcAmount`, `dstCurrency`, `dstChain`, `dstAmount`, `walletAddress`, `transactionHash`, `cryptoTxnInfo?` | Order fully completed, crypto sent |
| `ORDER_FAILED`             | `orderUid`, `status`                                                                                                                                       | Order failed or cancelled          |
| `ERROR`                    | `message`, `code?`                                                                                                                                         | Error occurred in the widget       |

### `CryptoTxnInfo`

Available in `ORDER_CREATED` and `ORDER_COMPLETED` event payloads:

| Field             | Type     | Description                                                     |
| ----------------- | -------- | --------------------------------------------------------------- |
| `currency`        | `string` | Crypto currency code, e.g. `"USDC"`                             |
| `chain`           | `string` | Chain code, e.g. `"ethereum"`                                   |
| `amount`          | `string` | Amount credited to the receiver                                 |
| `receiverAddress` | `string` | Address that received the crypto                                |
| `fillAmount`      | `string` | Filled/settled amount (may differ from amount on partial fills) |
| `senderAddress`   | `string` | Address that sent the crypto                                    |
| `transactionHash` | `string` | On-chain transaction hash                                       |
| `status`          | `string` | Status of the transaction                                       |

### Example: Full Event Handling

```javascript theme={null}
import { RampnowSdk, RampnowEventType } from '@rampnow/sdk'

const sdk = new RampnowSdk({
  apiKey: 'pk_live_YOUR_API_KEY',
  orderType: 'buy',
  dstCurrency: 'ETH',
  dstChain: 'ethereum',
})

sdk
  .on(RampnowEventType.WIDGET_READY, () => {
    console.log('Widget is ready')
  })
  .on(RampnowEventType.ORDER_CREATED, ({ payload }) => {
    console.log('Order created:', payload.orderUid)
  })
  .on(RampnowEventType.ORDER_COMPLETED, ({ payload }) => {
    console.log('Order completed:', payload.orderUid)
    console.log('Tx hash:', payload.transactionHash)
  })
  .on(RampnowEventType.ERROR, ({ payload }) => {
    console.error('Widget error:', payload.message)
  })
  .init()
```

***

## Commands

Commands are messages sent **from the SDK to the widget** using `sdk.send()`. This is the reverse direction of events.

<Warning>
  **Domain whitelisting required:** For security, the widget only accepts commands from whitelisted origins. To whitelist your domain, please [contact Rampnow](https://rampnow.io/contact-us). Commands sent from non-whitelisted origins will be silently ignored.
</Warning>

| Command                 | Payload               | Description                                          |
| ----------------------- | --------------------- | ---------------------------------------------------- |
| `UPDATE_PAYMENT_DETAIL` | `{ transactionHash }` | Update payment detail with a crypto transaction hash |

### Example: Submit a transaction hash from your wallet

```javascript theme={null}
import { RampnowSdk, RampnowEventType, RampnowCommandType } from '@rampnow/sdk'

const sdk = new RampnowSdk({ apiKey: 'pk_live_YOUR_API_KEY' })

// After your wallet completes a crypto transfer, send the hash to the widget
sdk.send(RampnowCommandType.UPDATE_PAYMENT_DETAIL, {
  transactionHash: '0xabc123...',
})

// Listen for confirmation that the payment is being processed
sdk.on(RampnowEventType.ORDER_PAYMENT_PROCESSING, ({ payload }) => {
  console.log('Payment updated:', payload.paymentStatus)
})
```

***

## When to Use the SDK

<AccordionGroup>
  <Accordion title="SDK vs Widget Mode (URL)" icon="code-compare">
    The SDK wraps the widget mode integration with a programmatic API. Use the SDK when you need:

    * Event-driven callbacks (order status updates)
    * Programmatic control (open/close the widget)
    * React integration via hooks
    * Type-safe configuration with TypeScript

    Use [Widget Mode](/api-reference/widget-mode) directly when you only need a simple iframe or redirect.
  </Accordion>

  <Accordion title="SDK vs Hosted Mode" icon="server">
    Use the SDK for a drop-in widget experience. Use [Hosted Mode](/api-reference/hosted-mode) when you need full control over the UI and want to build a custom flow using the REST APIs directly.
  </Accordion>
</AccordionGroup>

***

## Next Steps

* [View the live demo](https://demo.rampnow.io/)
* [Configure Webhooks](/api-reference/webhook) for server-side notifications
* [Explore Supported Assets](/quickstart/resources/supported-assets)
* [View API Documentation](/api-reference/overview)


# CreateCustomerUser
Source: https://docs.rampnow.io/api-reference/users/createcustomeruser

/api-reference/partner_external.yaml post /api/partner/v1/ext/customer_user



# GetCustomerUserKyc
Source: https://docs.rampnow.io/api-reference/users/getcustomeruserkyc

/api-reference/partner_external.yaml post /api/partner/v1/ext/customer_user/{uid}/kyc



# Webhook Configuration
Source: https://docs.rampnow.io/api-reference/webhook

Receive real-time notifications for transaction status updates

<Note>
  Webhooks are optional but recommended for tracking transaction status in real-time.
</Note>

## Overview

Webhooks allow you to receive automatic notifications when order events occur. Configure them in your Rampnow Partner Dashboard to stay updated on transaction statuses without polling.

## Configuration Steps

<Steps>
  <Step title="Access API Hub">
    Navigate to the **API Hub** in your [Rampnow Partner Dashboard](https://partner.rampnow.io/api/auth/signin?callbackUrl=%2F).
  </Step>

  <Step title="Add Webhook URL">
    Enter your server endpoint URL that will receive webhook notifications.

    <Warning>
      Ensure you have a dedicated API endpoint set up on your server to handle incoming webhook events.
    </Warning>
  </Step>

  <Step title="Select Event Types">
    Choose which events to receive:

    * **All events** - Get notified of every status change
    * **Specific events** - Select only the events you need
  </Step>
</Steps>

***

## Order Events

Each event carries an `eventType` and the current `orderStatus` in its payload. Ramp-order events use the `ramp_order.status_change` type. The concrete status is always in the `orderStatus` field of the payload — not in the event name.

### Order status semantics

The concrete status is in `payload.orderStatus`. The **Webhook** column shows which statuses are pushed to your endpoint — the rest are observable only by polling `GET /ext/ramp_order/{uid}`.

| Status               | Meaning                                                                                                                                                                                   | Terminal? | Webhook |
| -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- | ------- |
| `created`            | Order created, awaiting payment / start of processing.                                                                                                                                    | No        | Yes     |
| `processing`         | Payment received; crypto being settled on-chain to the user.                                                                                                                              | No        | Yes     |
| `completed`          | Crypto delivered to the destination wallet. Success — **immutable** once reached.                                                                                                         | Yes       | Yes     |
| `failed`             | A settlement attempt failed. **Not terminal** — Rampnow re-settles the order, so it can still move to `processing` → `completed`. Treat as "in-flight, needs retry," not a final failure. | No        | Yes     |
| `payment_failed`     | The user's fiat/card payment failed or was declined. **Terminal** — the user must create a new order to retry; the same order does not move back to `processing`.                         | Yes       | Yes     |
| `expired`            | Order not paid within its validity window.                                                                                                                                                | Yes       | Yes     |
| `canceled`           | Order canceled.                                                                                                                                                                           | Yes       | Yes     |
| `blocked`            | Transaction blocked by KYT (on-chain risk screening); also the state for a refunded order (you will see `paymentStatus: refunded`).                                                       | Yes       | Yes     |
| `payment_processing` | Async fiat payment authorizing/clearing. Internal transition — **no webhook**; poll if you need it.                                                                                       | No        | No      |

<Warning>
  **`failed` is not final.** Do not close or refund on your side when you receive `failed` — Rampnow retries and re-settles. Wait for `completed`, or poll the order.
</Warning>

<Note>
  Every terminal state now emits a webhook — including `expired`, `canceled` and `blocked` — so you no longer need to poll to observe a terminal failure. `completed` is immutable once reached.
</Note>

***

## Implementation Example

Here's a simple Flask server that receives webhook notifications:

<CodeGroup>
  ```python Python (Flask) theme={null}
  from flask import Flask, request, jsonify
  app = Flask(__name__)
  @app.route('/order/external', methods=['POST'])
  def orderwebhook():
      data = request.json  
      # partner logic based on event
      return jsonify({"status": "success"}), 200
  if __name__ == '__main__':
      app.run(port=3000)

  ```
</CodeGroup>

<Tip> Acknowledge receipt by returning **any `2xx` status** (`200`–`299`). The response body is ignored — an empty body is fine, and it does not need to be JSON. Any non-2xx response, or a connection/timeout error, is treated as a failed delivery and retried (see [Delivery & retries](#delivery-and-retries)). </Tip>

## Delivery and retries

* **Success** is determined solely by the HTTP status code: any `2xx` marks the event delivered. The response body, content type, and length are ignored.
* **Failure** is any non-2xx status or a transport error (connection refused, DNS, TLS, timeout).
* **Retries:** a failed event is retried up to **10 times** with exponential backoff, spanning roughly **24 hours** in total. Delivery is idempotent per event — the same `eventUid` is reused across retries, so de-duplicate on `eventUid`.
* **No auto-disable:** repeated failures never disable your endpoint. After the retry budget is exhausted the event stays in a failed state and can be re-sent manually from the Partner Dashboard.
* Because a completed order's webhook carries the final `dstFillAmount`, `transactionHash`, and `walletAddress`, a short outage on your side will not lose those values — they arrive on the next successful retry.

## Signature Verification

Every webhook is signed so you can verify it originated from Rampnow. Reject any request whose signature does not match.

| Header                | Description                                         |
| --------------------- | --------------------------------------------------- |
| `X-RAMPNOW-SIGN`      | Hex-encoded HMAC-SHA256 signature of the request    |
| `X-RAMPNOW-TIMESTAMP` | Unix timestamp (seconds) used in the signed message |

**Algorithm:** HMAC-SHA256, hex-encoded.

**Signing secret:** your API secret — the same secret you use to sign outbound API calls (from the API Hub in the Partner Dashboard). There is no separate webhook secret.

**Signed message** — the concatenation, in this exact order:

```
message = timestamp + "POST" + path + rawBody
```

* `timestamp` — the value of the `X-RAMPNOW-TIMESTAMP` header.
* `path` — the path (and query string, if any) of the webhook URL you registered, e.g. `/rampnow/webhook`.
* `rawBody` — the exact raw request body bytes, verified **before** any JSON re-serialization.

<CodeGroup>
  ```javascript Node.js theme={null}
  const crypto = require("crypto");

  // webhookPath is the path (+ query) of the URL you registered with Rampnow
  function verifyRampnowWebhook(req, apiSecret, webhookPath) {
    const timestamp = req.header("X-RAMPNOW-TIMESTAMP");
    const signature = req.header("X-RAMPNOW-SIGN");
    const rawBody = req.rawBody; // raw bytes, not JSON.stringify(req.body)

    const message = timestamp + "POST" + webhookPath + rawBody;
    const expected = crypto
      .createHmac("sha256", apiSecret)
      .update(message)
      .digest("hex");

    return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
  }
  ```

  ```python Python theme={null}
  import hmac, hashlib

  # webhook_path is the path (+ query) of the URL you registered with Rampnow
  def verify_rampnow_webhook(headers, raw_body: bytes, api_secret: str, webhook_path: str) -> bool:
      timestamp = headers["X-RAMPNOW-TIMESTAMP"]
      signature = headers["X-RAMPNOW-SIGN"]

      message = timestamp + "POST" + webhook_path + raw_body.decode("utf-8")
      expected = hmac.new(api_secret.encode(), message.encode(), hashlib.sha256).hexdigest()

      return hmac.compare_digest(signature, expected)
  ```
</CodeGroup>

<Warning>
  Capture the **raw** request body for verification. Frameworks that parse and re-serialize JSON can reorder keys or change whitespace, which changes the bytes and breaks the signature.
</Warning>

## Webhook Payload Schema

<Info>The webhook payload for On/Off Ramp Orders is shown below.</Info>

<CodeGroup>
  ```json On/Off Ramp Orders theme={null}
  {
    "createdAt": "2024-10-01T12:00:00Z",
    "eventUid": "853d470c-db91-4c6e-9724-acfccd138306",
    "eventType": "ramp_order.status_change",
    "payload": {
      "orderUid": "5de57551-3272-4af5-86a4-5eeae6ccc37f",
      "externalOrderUid": "1eda87a5-dcfb-4a14-89d9-d0384bcb4ead",
      "createTime": "2024-10-01T11:59:45",
      "updateTime": "2024-10-01T12:00:00Z",
      "partnerGeneratedUid": "707966cf-afc0-4577-bd42-cd79a5b6f629",
      "orderType": "buy",
      "orderStatus": "processing",
      "paymentStatus": "received",
      "paymentMode": "card",
      "srcCurrency": "USD",
      "srcChain": "fiat",
      "srcAmount": 100,
      "dstCurrency": "ETH",
      "dstChain": "ethereum",
      "dstAmount": 0.3,
      "dstFillAmount": 0.2997,
      "walletAddress": "0x535ebf73d0E20db0A72509207599C816510e11C9",
      "transactionHash": [
        "Ox235ebf73d0E20db0A72509207599C816510e11C9535ebf73d0E20db0A72509207599C816510e11C9"
      ],
      "feeDetails": [
        { "type": "platform", "fee": 1.0, "currency": "USD", "isInclusive": false },
        { "type": "network", "fee": 0.8, "currency": "USD", "isInclusive": false },
        { "type": "partner", "fee": 1.5, "currency": "USD", "isInclusive": false }
      ],
      "partnerFee": 1.5,
      "partnerCurrency": "USDC"
    }
  }
  ```
</CodeGroup>

## Field Descriptions

| Field                 | Type   | Description                                                                                                                                                                                                                                   |
| --------------------- | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `createdAt`           | string | Webhook event creation timestamp (ISO 8601)                                                                                                                                                                                                   |
| `eventUid`            | string | Unique webhook event identifier                                                                                                                                                                                                               |
| `eventType`           | string | Event type: `ramp_order.status_change`. The concrete status is in `payload.orderStatus`.                                                                                                                                                      |
| `orderUid`            | string | Unique Rampnow order identifier                                                                                                                                                                                                               |
| `externalOrderUid`    | string | External order reference                                                                                                                                                                                                                      |
| `createTime`          | string | Order creation timestamp (ISO 8601)                                                                                                                                                                                                           |
| `updateTime`          | string | Last update timestamp (ISO 8601)                                                                                                                                                                                                              |
| `partnerGeneratedUid` | string | Your internal order ID                                                                                                                                                                                                                        |
| `orderType`           | string | Transaction type: `buy` or `sell`                                                                                                                                                                                                             |
| `orderStatus`         | string | Current order status. See the [status table](#order-status-semantics) above for all values, their meaning, and which ones are pushed as webhooks.                                                                                             |
| `paymentStatus`       | string | Payment settlement status                                                                                                                                                                                                                     |
| `paymentMode`         | string | Payment method used (e.g., `card`, `google_pay`)                                                                                                                                                                                              |
| `srcCurrency`         | string | Source currency code                                                                                                                                                                                                                          |
| `srcChain`            | string | Source blockchain or `fiat`                                                                                                                                                                                                                   |
| `srcAmount`           | number | Amount in source currency                                                                                                                                                                                                                     |
| `dstCurrency`         | string | Destination currency code                                                                                                                                                                                                                     |
| `dstChain`            | string | Destination blockchain or `fiat`                                                                                                                                                                                                              |
| `dstAmount`           | number | **Quoted** amount in destination currency, fixed at order creation.                                                                                                                                                                           |
| `dstFillAmount`       | number | **Actual amount delivered** on-chain to the recipient. Set once the order reaches `completed`; `0` before then. Use this (not `dstAmount`) for reconciliation — the difference from `dstAmount` on an onramp is the on-chain network/gas fee. |
| `walletAddress`       | string | Recipient wallet address (the final recipient the crypto was sent to)                                                                                                                                                                         |
| `walletAddressTag`    | string | Optional wallet tag/memo                                                                                                                                                                                                                      |
| `transactionHash`     | array  | Blockchain transaction hash(es), set when the order completes                                                                                                                                                                                 |
| `feeDetails`          | array  | Fee breakdown; each entry has `type`, `fee`, `currency` (in `srcCurrency`). See [feeDetails types](/api-reference/hosted-mode#fee-breakdown-feedetails).                                                                                      |
| `partnerFee`          | number | Your partner fee / markup for the order                                                                                                                                                                                                       |
| `partnerCurrency`     | string | Currency of `partnerFee` — always `USDC` (the USDC-equivalent partner fee)                                                                                                                                                                    |

## Best Practices

<AccordionGroup>
  <Accordion title="Security" icon="shield">
    * Use HTTPS endpoints only
    * Always verify the `X-RAMPNOW-SIGN` signature (see [Signature Verification](#signature-verification)) and reject requests that fail
    * Implement rate limiting on your endpoint
    * Log all incoming webhooks for debugging
  </Accordion>

  <Accordion title="Reliability" icon="rotate">
    * Return `200 OK` quickly (process async if needed)
    * Implement idempotency using `orderUid`
    * Handle duplicate webhook deliveries gracefully
    * Set up monitoring and alerts for failures
  </Accordion>

  <Accordion title="Error Handling" icon="triangle-exclamation">
    * Always respond with status codes
    * Implement retry logic on your side if needed
    * Store failed webhooks for manual review
    * Contact support if webhooks stop arriving
  </Accordion>
</AccordionGroup>

## Testing Your Webhook

<Steps>
  <Step title="Set Up Local Endpoint">
    Run your webhook server locally on the specified port.
  </Step>

  <Step title="Use Tunneling Tool">
    Use tools like [ngrok](https://ngrok.com) to expose your local server:

    ```bash theme={null}
    ngrok http 3000
    ```
  </Step>

  <Step title="Add Tunnel URL">
    Copy the ngrok URL and add it to your Rampnow dashboard.
  </Step>

  <Step title="Create Test Order">
    Create a test order and verify your endpoint receives the webhook.
  </Step>
</Steps>

## Need Help?

If you encounter issues with webhook delivery or have questions about the payload structure, contact us at [support@rampnow.io](mailto:support@rampnow.io).


# Webhooks for ramp order status changes
Source: https://docs.rampnow.io/api-reference/webhooks/webhooks-for-ramp-order-status-changes

/api-reference/partner_external.yaml webhook ramp_order_status_change_webhook
Webhooks for ramp order status changes



# Widget Mode Integration
Source: https://docs.rampnow.io/api-reference/widget-mode

Embed Rampnow directly into your application for a seamless user experience

<Note>
  Widget Mode keeps users on your platform throughout the entire transaction flow via iframe or redirect.
</Note>

## Overview

Widget Mode allows you to embed Rampnow's on-ramp and off-ramp services directly into your application. Users complete transactions within an overlay or iframe without ever leaving your platform.

<div>
  <Card title="iFrame or Redirect" icon="code-branch">
    Choose between **iFrame** (embedded) or **Redirect** mode
  </Card>

  <Card title="Quick Setup" icon="bolt">
    Get started in minutes with URL parameters
  </Card>

  <Card title="All Payment Methods" icon="credit-card">
    Support for all available Rampnow payment modes
  </Card>

  <Card title="Customizable" icon="sliders">
    Pre-fill amounts, currencies and wallet addresses
  </Card>
</div>

<Tip>
  Want programmatic control with event handling and TypeScript support? Use the [Rampnow SDK](/api-reference/sdk) instead — it wraps Widget Mode with a developer-friendly API and a React hook.
</Tip>

***

## URL Parameters

Configure the widget by passing parameters in the URL:

| Parameter          | Required     | Default                               | Description                                                                     |
| ------------------ | ------------ | ------------------------------------- | ------------------------------------------------------------------------------- |
| `apiKey`           | **Required** | —                                     | Your unique API key from the [Partner Dashboard](https://partner.rampnow.io)    |
| `orderType`        | Optional     | `buy`                                 | Transaction type: `buy` or `sell`                                               |
| `srcChain`         | **Required** | `buy`: `fiat`<br />`sell`: `ethereum` | Source chain for the asset user is spending                                     |
| `srcCurrency`      | Optional     | `buy`: `EUR`<br />`sell`: `ETH`       | Currency user is spending (fiat for buy, crypto for sell)                       |
| `srcAmount`        | Optional     | `100`                                 | Amount in source currency                                                       |
| `dstCurrency`      | Optional     | `buy`: `ETH`<br />`sell`: `EUR`       | Currency user receives (crypto for buy, fiat for sell)                          |
| `dstChain`         | **Required** | `buy`: `ethereum`<br />`sell`: `fiat` | Destination chain for received currency                                         |
| `paymentMode`      | Optional     | Lowest fee                            | Payment method: `card`, `google_pay`, `apple_pay`, `open_banking`, `sepa`, etc. |
| `walletAddress`    | Optional     | —                                     | User's crypto wallet address                                                    |
| `walletAddressTag` | Optional     | —                                     | Wallet tag/memo for supported chains (XRP, XLM, etc.)                           |
| `externalOrderId`  | Optional     | —                                     | Your internal order ID for tracking                                             |

***

## iFrame Mode

Embed the widget directly on your page for a seamless experience.

<Steps>
  <Step title="Create Container">
    Add a container element in your HTML:

    ```html theme={null}
    <div id="ramp-container"></div>
    ```
  </Step>

  <Step title="Construct Widget URL">
    Build your URL with the required parameters:

    ```
    https://app.rampnow.io/order/quote?apiKey=YOUR_API_KEY&srcCurrency=EUR&srcAmount=250&dstCurrency=BTC&dstChain=bitcoin&walletAddress=0xYourWalletAddress
    ```
  </Step>

  <Step title="Initialize iFrame">
    Embed the widget using an iframe:

    ```html theme={null}
    <iframe 
      src="https://app.rampnow.io/order/quote?apiKey=YOUR_API_KEY&srcCurrency=EUR&srcAmount=250&dstCurrency=BTC&dstChain=bitcoin&walletAddress=0xYourWalletAddress" 
      title="Rampnow Widget"
      width="100%"
      height="600px"
      frameborder="0"
      allow="payment">
    </iframe>
    ```
  </Step>
</Steps>

<Tip>
  The widget will be embedded inside your container, providing an in-page experience for users.
</Tip>

***

## Redirect Mode

Redirect users to Rampnow's hosted page for a simpler integration.

<Steps>
  <Step title="Construct Widget URL">
    Build your URL with the required parameters:

    ```
    https://app.rampnow.io/order/quote?apiKey=YOUR_API_KEY&srcCurrency=EUR&srcAmount=250&dstCurrency=BTC&dstChain=bitcoin&walletAddress=0xYourWalletAddress
    ```
  </Step>

  <Step title="Redirect User">
    Redirect the user to the constructed URL:

    ```javascript theme={null}
    window.location.href = "https://app.rampnow.io/order/quote?apiKey=YOUR_API_KEY&srcCurrency=EUR&srcAmount=250&dstCurrency=BTC&dstChain=bitcoin&walletAddress=0xYourWalletAddress";
    ```
  </Step>
</Steps>

In this example, the user buys **250 EUR** worth of **BTC** on the Bitcoin chain, with crypto sent to `0xYourWalletAddress`.

***

## Webhook Integration

Track transaction status in real-time by configuring webhooks in your Rampnow Partner Dashboard.

<Tip>
  [Set up webhooks](/api-reference/webhook) to receive notifications when users start or complete transactions.
</Tip>

***

## When to Use Widget Mode

<AccordionGroup>
  <Accordion title="Ideal For" icon="check">
    * Platforms wanting a deeply integrated user experience
    * Partners looking for quick integration with minimal code
    * Applications needing all available payment modes
    * Teams wanting consistent, pre-built UI
  </Accordion>

  <Accordion title="Benefits" icon="bolt">
    * Fastest integration method — no custom UI needed
    * All payment methods supported out of the box
    * Pre-fill user data for convenience
    * Automatic updates without code changes
  </Accordion>
</AccordionGroup>

***

## Next Steps

<div>
  <Card title="Rampnow SDK" icon="cube" href="/api-reference/sdk">
    Upgrade to the SDK for event handling, TypeScript support, and a React hook
  </Card>

  <Card title="Webhooks" icon="bell" href="/api-reference/webhook">
    Set up server-side transaction notifications
  </Card>

  <Card title="Supported Assets" icon="coins" href="/quickstart/resources/supported-assets">
    View supported cryptocurrencies and fiat currencies
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference/overview">
    Explore the complete API documentation
  </Card>
</div>


# Build with Rampnow.
Source: https://docs.rampnow.io/index



<div>
  <img alt="bitcoin" />

  <img alt="bnb" />

  <div>
    # Build with Rampnow.

    <p>
      A unified API for global fiat↔blockchain flows. Rampnow provides onramp,
      offramp and payout services through a single infrastructure layer. For
      cross-chain swaps and bridging, <a href="https://docs.hypermid.io">Hypermid</a> provides
      dedicated infrastructure through a unified API. Fast settlement, multi-chain
      support and production-ready endpoints built for wallets, exchanges,
      dApps and fintechs.
    </p>

    <div>
      <a href="/quickstart">
        Start Here →
      </a>
    </div>
  </div>

  <img alt="USD Coin" />

  <img alt="ethereum" />

  <img alt="SOL" />

  <img alt="USDC" />
</div>

<h2>Quickstart</h2>

<Columns>
  <Card title="Onramp" icon="arrow-trend-up" href="/quickstart/onramp/onramp">
    Enable users to buy crypto with fiat currency using cards, bank transfers and local payment methods.
  </Card>

  <Card title="Offramp" icon="arrow-trend-down" href="/quickstart/offramp/offramp">
    Allow users to sell crypto and receive fiat directly to their bank accounts or cards.
  </Card>

  <Card title="Rampnow Wallet (Launching Soon) " icon="wallet">
    Create and manage custodial wallets for your users with built-in security features.
  </Card>

  <Card title="Swap & Bridge (Launching Soon)" icon="arrow-right-arrow-left">
    Enable instant crypto-to-crypto swaps and move assets seamlessly across different blockchain networks.
  </Card>
</Columns>

<h2>Need Help?</h2>

<Columns>
  <Card title="Contact us" icon="pen-fancy" href="https://rampnow.io/en/contact-us">
    Contact our support.
  </Card>

  <Card title="Request Sales" icon="code" href="https://rampnow.io/en/list#list-token-form">
    Contact our sales.
  </Card>
</Columns>


# Platform overview
Source: https://docs.rampnow.io/quickstart/learn/overview

Modular building blocks for global fiat ↔ blockchain money movement

<Note>
  With a single integration, accept fiat payments, convert to digital assets, and access <ChainCount /> supported blockchains and pay users out in local currencies.
</Note>

## Core Products

<div>
  <Card title="Onramp" icon="arrow-right-to-bracket" href="/quickstart/onramp/onramp">
    Accept fiat deposits and deliver assets to wallets with fast settlement
  </Card>

  <Card title="Offramp" icon="arrow-right-from-bracket" href="/quickstart/offramp/offramp">
    Convert digital assets to EUR and send funds to bank accounts via SEPA
  </Card>

  <Card title="Swap & Bridge — Hypermid" icon="shuffle" href="https://docs.hypermid.io">
    Route swaps and cross-chain transfers across supported networks with optimized pricing
  </Card>

  <Card title="Rampnow Wallet (Coming Soon)" icon="wallet" href="/quickstart/rampnow-wallet/rampnow-wallet">
    A non-custodial smart wallet for retail users with built-in AA, multi-chain support, secure signing and direct onramp integration
  </Card>
</div>

## Integration models

Rampnow offers three ways to integrate — pick based on how much of the UI you want to own:

| Model           | You build                                                                                                                 | Rampnow handles                         | Best for                                                       |
| --------------- | ------------------------------------------------------------------------------------------------------------------------- | --------------------------------------- | -------------------------------------------------------------- |
| **Hosted mode** | Your own screens; you call the REST API server-to-server and redirect the user to a Rampnow-hosted page for payment + KYC | Payment capture, KYC, settlement        | Full control of the surrounding UX with minimal PCI/KYC burden |
| **Widget**      | An embed/iframe or redirect to Rampnow's prebuilt widget                                                                  | The entire buy/sell UI, payment and KYC | Fastest launch, least code                                     |
| **SDK**         | A thin client using our SDK to call the API                                                                               | Same as hosted, with typed helpers      | Teams wanting a typed client over the REST API                 |

See [Hosted mode](/api-reference/hosted-mode), [Widget mode](/api-reference/widget-mode) and the [SDK](/api-reference/sdk) for details.

## Onramp: Accept fiat and deliver digital assets

<AccordionGroup>
  <Accordion title="Payment Methods" icon="credit-card">
    See the [Payment Methods & Limits](/quickstart/resources/payment-methods) page for the current list of cards, bank transfers and local payment methods by region.
  </Accordion>

  <Accordion title="Coverage" icon="globe">
    * **<ChainCount /> blockchains** supported
    * **<TokenCount /> tokens** available
    * **Multi-chain coverage** across all major networks
  </Accordion>
</AccordionGroup>

<Card title="Learn More" icon="book" href="/quickstart/onramp/onramp">
  View complete Onramp documentation →
</Card>

## Offramp: Cash out to bank accounts

<Tabs>
  <Tab title="Supported Currencies">
    * EUR (expanding continuously)
  </Tab>

  <Tab title="Settlement Rails">
    * SEPA transfers
    * Card payouts (Coming Soon)
  </Tab>

  <Tab title="Use Cases">
    * Wallet withdrawals
    * Exchange cash-outs
    * Earnings payouts
    * Asset exits
  </Tab>
</Tabs>

<div>
  <Card title="Overview" icon="book" href="/quickstart/offramp/offramp">
    Offramp flow
  </Card>

  <Card title="Currencies" icon="coins" href="/quickstart/offramp/settlement-methods">
    Supported fiat
  </Card>

  <Card title="Methods" icon="building-columns" href="/quickstart/offramp/settlement-methods">
    Settlement options
  </Card>
</div>

***

## Swap & Bridge

For cross-chain swaps and bridging, explore [Hypermid](https://docs.hypermid.io), our dedicated cross-chain infrastructure product.

Hypermid provides infrastructure for swapping assets and bridging between supported blockchain networks through a unified API.

[Learn more about Hypermid →](https://docs.hypermid.io)

***

## Customers

<AccordionGroup>
  <Accordion title="Customer Management" icon="user">
    Customer objects for end-users and businesses with full lifecycle management
  </Accordion>
</AccordionGroup>

***

## Next Steps

<div>
  <Card title="Quickstart Guide" icon="rocket" href="/quickstart/learn/why-rampnow">
    New to Rampnow? Start here
  </Card>

  <Card title="Payment Methods" icon="credit-card" href="/quickstart/resources/payment-methods">
    View supported payment rails
  </Card>

  <Card title="Blockchain List" icon="link" href="/quickstart/resources/blockchain-list">
    See all supported chains
  </Card>

  <Card title="Contact Sales" icon="headset" href="https://rampnow.io/en/list#list-token-form">
    Need support?
  </Card>
</div>

<Check>
  Rampnow is designed to be the **invisible infrastructure** behind your product—so you can focus on UX, while we handle payments and routing.
</Check>


# Why Rampnow
Source: https://docs.rampnow.io/quickstart/learn/why-rampnow

Unified infrastructure for global fiat ↔ blockchain money movement

## The onboarding challenge

Today's fiat-to-blockchain landscape is fragmented, slow, and heavily regional. Developers often struggle to integrate multiple payment providers, each burdened by different local banking rules, limited network support, and restrictive regional coverage.

For platforms requiring global scalability, these fragmented rails result in high payment failure rates and friction-filled user onboarding.

**The result:** Businesses struggle to offer a smooth, global money movement experience, losing users at the checkout and facing massive integration overhead.

## Rampnow's solution

Rampnow eliminates this complexity by providing complete onramp and offramp infrastructure with advanced liquidity routing through a **single, globally accessible API**.

We handle payments and settlements end-to-end. Our unified infrastructure supports **<ChainCount /> blockchains**, **<TokenCount /> tokens** and multi-currency fiat settlements.

This drastically reduces vendor fragmentation, increases conversion, and simplifies global deployment. With Rampnow, businesses can launch modern money-movement products faster, with significantly lower risk and minimal operational overhead.

## What you can build

### Onramp

Enable your users to purchase digital assets instantly using:

* **Cards:** Visa, Mastercard, Apple Pay, Google Pay
* **Bank transfers:** SEPA, ACH, PIX, UPI
* **Local payment methods:** Country-specific options across EU, APAC, LATAM, Africa
* **Multi-chain support:** <ChainCount /> blockchains and <TokenCount /> tokens

### Offramp

Let users convert digital assets back to fiat and receive funds directly:

* **Supported currencies:** EUR (expanding continuously)
* **Settlement methods:** SEPA (expanding continuously)
* **Automated liquidity routing:** Best rate execution per asset and chain

Useful for wallets, dApps, exchanges and marketplaces where users need to withdraw funds securely.

### Swap & Bridge

For cross-chain swaps and bridging, explore [Hypermid](https://docs.hypermid.io), our dedicated cross-chain infrastructure product.

Hypermid enables seamless asset movement across tokens and blockchains through a unified API, with multi-source liquidity aggregation, route selection, cross-chain bridging and real-time execution visibility.

## Get started

<Steps>
  <Step title="Quickstart">
    [Make your first API request in minutes](/api-reference/quickstart)
  </Step>

  <Step title="On-Offramp">
    [Implement fiat-to-blockchain flows with sample code](/api-reference/hosted-mode)
  </Step>

  <Step title="Webhooks">
    [Integrate crypto-to-fiat flows with webhooks](/api-reference/webhook)
  </Step>

  <Step title="API Reference">
    [Visit our API reference.](/api-reference/overview)
  </Step>
</Steps>

## Why choose Rampnow?

<Check>One API for onramp and offramp, with Hypermid for cross-chain swaps and bridging</Check>
<Check>Large network coverage: <ChainCount /> blockchains, <TokenCount /> tokens</Check>
<Check>Fast fiat settlement across supported currencies</Check>
<Check>Supports cards, SEPA, UPI and local rails</Check>
<Check>Optimized payment routing</Check>
<Check>Reliable uptime and monitoring</Check>
<Check>Simple integration with clear documentation</Check>

## Getting help

Questions? We're here to help you go live quickly.

**Technical Support:** [support@rampnow.io](mailto:support@rampnow.io)

**Sales:** [partnership@rampnow.io](mailto:partnership@rampnow.io)


# Chains and tokens
Source: https://docs.rampnow.io/quickstart/offramp/chains-and-tokens

Browse supported tokens and blockchains available for selling digital assets to fiat using Rampnow’s offramp.

<Note>
  Offramp asset availability is based on liquidity and network stability. Only assets with `assetConfigs[<asset>].orderTypeConfigs.sell.status = "active"` are enabled for user withdrawals.
</Note>

## Network Coverage

<div>
  <Card title={<><ChainCount /> Blockchains</>} icon="layer-group">
    Offramp coverage across major L1s, L2s and sidechains
  </Card>

  <Card title={<><TokenCount /> Tokens</>} icon="coins">
    Liquid assets available for conversion into fiat
  </Card>

  <Card title="EVM & Non-EVM" icon="code-branch">
    Support for EVM chains, Bitcoin and other non-EVM networks
  </Card>

  <Card title="Dynamic Availability" icon="arrows-rotate">
    Routes managed in real time based on liquidity
  </Card>
</div>

## Supported Network Types

<Card title="Skip to Offramp Asset Explorer" icon="arrow-down" href="#supported-assets">
  Jump directly to the interactive asset list to search and filter supported offramp assets.
</Card>

<Tabs>
  <Tab title="Layer 1">
    **Major L1 blockchains (offramp-enabled):**

    * Ethereum
    * Bitcoin
    * Solana
    * Avalanche
    * BNB Smart Chain
    * Other supported mainnets
  </Tab>

  <Tab title="Layer 2">
    **Ethereum L2 networks:**

    * Arbitrum One
    * Base
    * Optimism
    * Polygon zkEVM
  </Tab>

  <Tab title="Sidechains & Alt L1s">
    **Popular alt networks:**

    * Polygon
    * Other EVM-compatible chains
  </Tab>

  <Tab title="Non-EVM & Special Networks">
    **Non-EVM or specialized networks:**

    * Bitcoin
    * Solana
    * Selected additional non-EVM chains (where supported)
  </Tab>
</Tabs>

## Popular Offramp Networks

<AccordionGroup>
  <Accordion title="Ethereum & L2 Ecosystem" icon="ethereum">
    **Offramp-enabled networks:**

    * Ethereum
    * Arbitrum One
    * Base
    * Optimism
    * Polygon
    * Other supported EVM L2s

    <Check>ERC-20 tokens with sufficient liquidity and active sell routes are eligible for fiat payouts.</Check>
  </Accordion>

  <Accordion title="Bitcoin & Major Non-EVM" icon="bitcoin">
    **Supported non-EVM cores:**

    * Bitcoin (BTC)
    * Solana (SOL)
    * Other non-EVM networks where liquidity allows

    <Tip>Native BTC and selected non-EVM assets can be cashed out directly to supported fiat rails.</Tip>
  </Accordion>

  <Accordion title="Emerging Networks" icon="rocket">
    **New & expanding chains (where supported):**

    * Additional EVM L1s and L2s
    * Selected DeFi ecosystems
    * New rollups and appchains

    <Warning>Availability may vary by region and volume.</Warning>
  </Accordion>
</AccordionGroup>

## Offramp Asset Management

<Steps>
  <Step title="Eligibility & Routing">
    Only assets with active sell routes and sufficient liquidity are made available for offramp.
  </Step>

  <Step title="Dynamic Corridor Control">
    Availability is corridor-specific (token → fiat → payout rail) and may vary per country or partner.
  </Step>

  <Step title="Automatic De-Listing">
    Assets may be temporarily or permanently disabled if liquidity, risk, or regulatory profiles change.
  </Step>
</Steps>

<Info>
  Use the interactive explorer below to search and filter supported offramp assets by token, symbol, or blockchain. Data is pulled directly from Rampnow's live configuration API (`assetConfigs[<asset>].orderTypeConfigs.sell.status = "active"`).
</Info>

## Real-time explorer

Use the explorer below to browse supported tokens and chains pulled directly from our API.

# Supported Assets

<TokenExplorer />


# Offramp Overview
Source: https://docs.rampnow.io/quickstart/offramp/offramp

Convert digital assets to fiat using Rampnow's global offramp and payout infrastructure.

Rampnow's offramp lets your users convert digital assets into fiat and withdraw funds directly to their bank accounts or supported payout methods. Built for wallets, exchanges, dApps and fintechs that need reliable blockchain → fiat flows with predictable settlement.

<Note>
  The offramp runs on the same unified infrastructure as the onramp, with transparent pricing and regional payout coverage.
</Note>

## Why use Rampnow for offramps?

<div>
  <Card title="Global payout coverage" icon="globe">
    * Payouts to bank accounts via SEPA
    * EUR support today, with more currencies expanding continuously
  </Card>

  <Card title="Unified API" icon="code">
    * Same integration surface as onramp
    * Consistent order lifecycle, webhooks and status events
    * Automatic routing to best liquidity and payout rail
  </Card>

  <Card title="Operational reliability" icon="chart-line">
    * Deterministic quotes with clear fees and FX
    * Configurable limits per user, method and corridor
    * Reconciliation support for finance teams
  </Card>
</div>

## Core capabilities

<Steps>
  <Step title="Quote & eligibility checks">
    Before a sell order is created, Rampnow validates the requested asset and chain, checks corridor availability and returns:

    * Fiat amount
    * Fees and FX
    * Estimated delivery time
    * Applicable limits

    This helps you show users **exactly what they will receive** before initiating the transfer.
  </Step>

  <Step title="Asset collection">
    Rampnow supports two main models:

    **User-initiated transfer**: User sends assets from their wallet to a Rampnow-provided address.

    **Platform-initiated transfer**: Partner sends assets from custody/omnibus wallet after user confirmation.

    Each order is tied to a unique reference for deterministic matching and reconciliation.
  </Step>

  <Step title="FX & treasury routing">
    Once assets are received and confirmed on-chain, Rampnow:

    * Converts assets into EUR using connected liquidity
    * Routes funds via SEPA
    * Applies risk-based checks and velocity limits
  </Step>

  <Step title="Fiat payout">
    Users receive fiat via:

    * **Bank transfer** (SEPA)

    Each order emits clear status updates: `processing`, `completed`, `failed` (retried/re-settled), and `blocked` (funds refunded).
  </Step>

  <Step title="Reporting & reconciliation">
    Rampnow provides:

    * Order-level records (asset, chain, user, fiat, fees)
    * Payout references and bank trace IDs
    * Exportable data for accounting and tax reporting
    * Webhooks for real-time status updates
  </Step>
</Steps>

## Typical use cases

<AccordionGroup>
  <Accordion title="Withdrawal flows for exchanges and wallets">
    Let users cash out to their bank with minimal friction.
  </Accordion>
</AccordionGroup>

## Developer experience

The offramp is exposed through:

* The same **order/quote APIs** as onramp
* **Webhooks** for order and payout status
* Clear **error codes** and lifecycle states

<Tabs>
  <Tab title="Widget-based">
    Fastest to implement with pre-built UI components.
  </Tab>

  <Tab title="Direct API">
    Full control over UX and orchestration.
  </Tab>
</Tabs>

## What's next?

<div>
  <Card title="Offramp Flow" icon="arrow-right" href="/quickstart/offramp/offramp-flow">
    Full end-to-end sell & payout journey
  </Card>

  <Card title="Supported Fiat & Methods" icon="money-bill" href="/quickstart/offramp/settlement-methods">
    Currencies, rails and limits
  </Card>

  <Card title="Integration Options" icon="plug" href="/api-reference/quickstart">
    Widget vs. API vs. combined flows
  </Card>
</div>


# Offramp Flow
Source: https://docs.rampnow.io/quickstart/offramp/offramp-flow

Step-by-step overview of the complete digital-asset-to-fiat withdrawal journey

<Info>
  This guide walks through the full offramp journey — from quote creation and asset transfer to fiat payout execution. Rampnow manages blockchain monitoring, liquidity routing and payout execution in every step.
</Info>

<Frame>
  <img alt="Offramp flow diagram" />
</Frame>

## Complete Withdrawal Journey

<Steps>
  <Step title="Sell Quote Generation" icon="calculator">
    The client requests a **sell quote** specifying the digital asset being sold and the target fiat currency.

    <Frame>
      <img alt="Sell quote page" />
    </Frame>

    **Request parameters:**

    * Token & blockchain
    * Crypto amount
    * Desired payout currency
    * User region (auto-detected or provided)

    **Rampnow returns:**

    * Estimated fiat amount
    * FX and payout fees
    * Network fee
    * Estimated payout arrival time
    * Available payout methods

    <Tip>Quotes are deterministic and guarantee the payout amount after asset confirmation.</Tip>
  </Step>

  <Step title="User Sends Crypto" icon="wallet">
    The user initiates a blockchain transfer to the **specified deposit address** generated for the order.

    <Frame>
      <img alt="User sending crypto" />
    </Frame>

    **Rampnow monitors:**

    * Incoming transaction
    * Confirmations on the blockchain
    * Token matching & amount validation
    * Expiration handling if no funds are received

    **Status transitions:**

    * `created` → order created, awaiting the user's crypto deposit
    * `processing` → funds received and confirmed; conversion + payout in progress

    <Note>Each order has to be updated with transaction hash for accurate reconciliation.</Note>
  </Step>

  <Step title="Fiat Payout Execution" icon="building-columns">
    Rampnow sends fiat to the user's bank or local payout method.

    <Frame>
      <img alt="Payout screen" />
    </Frame>

    **Supported payout rails:**

    <Tabs>
      <Tab title="Bank Transfers">
        * SEPA (EU)
      </Tab>

      <Tab title="Card / Wallet (Coming Soon)">
        * Visa Direct
        * Mobile wallets
        * Regional payout partners
      </Tab>
    </Tabs>

    <Tip>Payout timing depends on the selected rail (instant → 1–2 business days).</Tip>
  </Step>

  <Step title="Order Completion" icon="check-circle">
    Once fiat is delivered, the offramp flow is completed and final confirmations are issued.

    **Final outputs:**

    * Transaction hash (crypto side)
    * Banking reference / trace ID (fiat side)
    * Final webhook: `ramp_order.status_change` with `payload.orderStatus = completed`

    <Check>Users can track blockchain delivery and payout references for transparency.</Check>
  </Step>
</Steps>

## Flow Characteristics

<Columns>
  <Card title="Transparent" icon="eye">
    Clear fees, FX and payout timelines communicated upfront
  </Card>

  <Card title="Reliable" icon="check-double">
    Deterministic routing and predictable payout execution
  </Card>

  <Card title="Global" icon="globe">
    EUR settlement coverage with reliable payout execution
  </Card>
</Columns>

## Integration Options

<div>
  <Card title="Widget Integration" icon="window" href="/api-reference/widget-mode">
    Drop-in offramp widget with complete flow
  </Card>

  <Card title="API Integration" icon="code" href="/api-reference/hosted-mode">
    Full control over order creation, UI and payouts
  </Card>
</div>

## Next Steps

<Steps>
  <Step title="Review Offramp APIs">
    Understand how to create sell quotes and orders via API
  </Step>

  <Step title="Implement Webhooks">
    Receive status updates for payout tracking and reconciliation
  </Step>

  <Step title="Explore Supported Currencies">
    Check available fiat currencies, payout rails and regional limits
  </Step>
</Steps>

<Card title="Ready to integrate the Offramp?" icon="rocket" href="/api-reference/overview">
  Start with the API documentation
</Card>


# Settlement Methods
Source: https://docs.rampnow.io/quickstart/offramp/settlement-methods

Overview of fiat payout rails and settlement behavior for Offramp transactions.

Rampnow currently only supports EUR via SEPA for its off-ramp infrastructure, allowing users to receive fiat after selling digital assets within standard SEPA processing times.

This page explains how settlement works, what payout rails are available and what partners need to consider when integrating the Offramp.

<Info>
  Settlement consists of two parts:

  1. **Asset settlement** — receiving and confirming the user's crypto transfer
  2. **Fiat settlement** — sending fiat to the user's chosen payout method\
     Both parts are fully orchestrated by Rampnow’s infrastructure.
</Info>

# How Settlement Works

<Steps>
  <Step title="1. Crypto Received & Confirmed" icon="wallet">
    When a user sends digital assets:

    * Rampnow detects the on-chain transfer
    * Confirms the required number of network confirmations
    * Locks the quote (payout is now guaranteed)
    * Updates the order status to `processing` (payment status becomes `received`)

    <Note>Confirmations depend on network conditions and chain security parameters.</Note>
  </Step>

  <Step title="2. Conversion to Fiat" icon="arrows-rotate">
    Once assets are received, Rampnow converts the tokens into the payout fiat currency using connected liquidity.

    **What happens here:**

    * Token → Fiat conversion
    * FX rate applied
    * Payout fee calculated
    * Optimal payout rail selected

    <Info>This conversion process is nearly instant for supported chains and tokens.</Info>
  </Step>

  <Step title="3. Fiat Payout Execution" icon="building-columns">
    Rampnow initiates a payout via SEPA.\
    The payout reference or order ID is generated at this stage if supported by the rail.

    **Status transitions:**

    * `processing` → conversion + payout in progress
    * `completed` → fiat delivered, order complete

    A settlement that cannot be completed ends in `failed` (retried/re-settled by Rampnow) or `blocked` (funds refunded).
  </Step>
</Steps>

# Supported Payout Methods

## 📌 Bank Transfers

Rampnow currently supports EUR payouts via SEPA only. Additional currencies and rails are on the roadmap.

| Rail                     | Region | Currencies | Speed           | Notes                     |
| ------------------------ | ------ | ---------- | --------------- | ------------------------- |
| **SEPA Credit Transfer** | EU     | EUR        | Same day or T+1 | Widely used across Europe |

## 💳 Card Payouts *(Roadmap)*

| Method              | Currency       | Speed          | Status      |
| ------------------- | -------------- | -------------- | ----------- |
| **Visa Direct**     | Multi-currency | Instant–30 min | Coming soon |
| **Mastercard Send** | Multi-currency | Instant        | Coming soon |

<Card icon="clock" title="Coming Soon">
  Rampnow is adding global card payout support for instant, card-to-bank withdrawals.
</Card>

# Settlement Times Overview

<div>
  <Card title="Same Day" icon="clock">
    SEPA Credit Transfer
  </Card>

  <Card title="T+1" icon="calendar">
    SEPA Credit Transfer (bank cut-off dependent)
  </Card>
</div>

<Note>
  Settlement timing may vary based on banking cut-off times, weekends, holidays and user region.
</Note>

# Webhook Events for Settlement

Rampnow sends webhook updates for every stage of offramp settlement:

```json theme={null}
{
  "createdAt": "2024-10-01T12:00:00Z",
  "eventUid": "853d470c-db91-4c6e-9724-acfccd138306",
  "eventType": "ramp_order.status_change",
  "payload": {
    "orderUid": "asdasnd-askdjnasjkdn-aksdnaksdn",
    "externalOrderUid": "vsdasnd-askdjnasjkdn-aksdnaksdn",
    "createTime": "2024-10-01T11:59:45",
    "updateTime": "2024-10-01T12:00:00Z",
    "orderType": "sell",
    "orderStatus": "completed",
    "paymentStatus": "received",
    "paymentMode": "sepa",
    "srcCurrency": "ETH",
    "srcChain": "ethereum",
    "srcAmount": 0.3,
    "dstCurrency": "EUR",
    "dstChain": "fiat",
    "dstAmount": 100,
    "dstFillAmount": 99.5,
    "walletAddress": "0xINF98983WKJENRIKjjDEER989",
    "transactionHash": ["OxtransactionHash"]
  }
}
```


# Supported Chains & Tokens
Source: https://docs.rampnow.io/quickstart/onramp/chains-and-tokens

Browse tokens across multiple blockchains available for onramp purchases.

<Note>
  Asset availability is based on liquidity and network stability. Only assets with `assetConfigs[<asset>].orderTypeConfigs.buy.status = "active"` are displayed to users.
</Note>

## Network Coverage

<div>
  <Card title={<><ChainCount /> Blockchains</>} icon="layer-group">
    Comprehensive coverage across all major networks
  </Card>

  <Card title={<><TokenCount /> Tokens</>} icon="coins">
    Verified assets from partner liquidity sources
  </Card>

  <Card title="EVM & Non-EVM" icon="code-branch">
    Support for L1, L2, sidechains and rollups
  </Card>

  <Card title="Dynamic Availability" icon="arrows-rotate">
    Real-time updates per payment method & region
  </Card>
</div>

## Supported Network Types

<Card title="Skip to Token Explorer" icon="arrow-down" href="#supported-assets-2">
  Jump directly to the interactive token list to search and filter supported assets.
</Card>

<Tabs>
  <Tab title="Major L1 Networks">
    **Major L1 blockchains:**

    * Ethereum
    * Bitcoin
    * Solana
    * Avalanche
    * Cardano
    * Tezos
    * Flow
    * And more...
  </Tab>

  <Tab title="L2 Networks">
    **Ethereum L2 solutions:**

    * Arbitrum
    * Optimism
    * Base
    * Polygon zkEVM
    * zkSync
    * Scroll
    * Linea
    * Blast
    * Mode
  </Tab>

  <Tab title="Ecosystem Chains">
    **Popular sidechains and ecosystem networks:**

    * Polygon
    * BNB Chain
    * Gnosis
    * Ronin
    * Moonbeam
    * Moonriver
    * Sui
    * TON
    * Tron
    * Fantom
    * Cronos
    * Kaia
  </Tab>

  <Tab title="Emerging Blockchains">
    **New and emerging networks:**

    * Aptos (coming soon)
    * Berachain
    * Monad
    * Unichain
    * Abstract
    * Sonic
    * Soneium
    * World Chain
    * Ink
  </Tab>
</Tabs>

## Popular Networks

<AccordionGroup>
  <Accordion title="Ethereum Ecosystem" icon="ethereum">
    **Mainnet + L2s:**

    * Ethereum
    * Arbitrum One
    * Optimism
    * Base
    * zkSync Era
    * Polygon zkEVM
    * Scroll
    * Linea
    * Blast
    * Taiko
    * Mantle

    <Check>Full ERC-20 token support with automatic contract verification</Check>
  </Accordion>

  <Accordion title="High-Performance Chains" icon="bolt">
    **Fast & scalable networks:**

    * Solana
    * Sui
    * Avalanche C-Chain
    * BNB Smart Chain
    * Polygon
    * Fantom

    <Info>Optimized for gaming, DeFi and high-frequency applications</Info>
  </Accordion>

  <Accordion title="Bitcoin & Forks" icon="bitcoin">
    **Bitcoin networks:**

    * Bitcoin (BTC)
    * Bitcoin Cash (BCH)
    * Litecoin (LTC)
    * Dogecoin (DOGE)
    * Rootstock (RSK)

    <Tip>Native BTC purchases with direct wallet delivery</Tip>
  </Accordion>

  <Accordion title="Emerging Networks" icon="rocket">
    **New & growing chains:**

    * Berachain
    * Monad
    * Unichain
    * Abstract
    * Sonic
    * Soneium
    * World Chain
    * Ink

    <Warning>Availability may vary by region and liquidity</Warning>
  </Accordion>
</AccordionGroup>

## Asset Management

<Steps>
  <Step title="Automatic Verification" icon="shield-check">
    All tokens are verified from partner liquidity sources before being made available
  </Step>

  <Step title="Risk Monitoring" icon="chart-line">
    Continuous monitoring for high-risk assets with automatic removal when necessary
  </Step>

  <Step title="Liquidity-Based Display" icon="water">
    Only tokens with sufficient liquidity and active buy routes are shown
  </Step>
</Steps>

## Real-Time Asset Explorer

<Info>
  Use the interactive explorer below to search and filter supported assets. Data is pulled directly from our live API.
</Info>

### Supported Assets

Hundreds of tokens across dozens of chains — see the live explorer below for current coverage.

<Frame>
  <img alt="Real-time asset explorer interface" />
</Frame>

<Tip>
  The asset list updates automatically based on:

  * Current liquidity availability
  * Payment method compatibility
  * Network status
</Tip>

## Popular Token Categories

<div>
  <Card title="Stablecoins" icon="dollar-sign">
    USDC, USDE, FDUSD, PYUSD and 50+ more
  </Card>

  <Card title="Native Tokens" icon="gem">
    ETH, BTC, SOL, AVAX, BNB, MATIC and all major L1 tokens
  </Card>

  <Card title="DeFi Tokens" icon="chart-network">
    AAVE, UNI, LINK, CRV, LDO and 100+ DeFi protocols
  </Card>

  <Card title="Gaming Assets" icon="gamepad">
    AXS, SAND, MANA, IMX, GALA and gaming tokens
  </Card>

  <Card title="Memecoins" icon="face-smile">
    DOGE, SHIB, PEPE, WIF, BONK and trending memes
  </Card>

  <Card title="LSTs & LRTs" icon="layer-group">
    stETH, rETH, ezETH, weETH and liquid staking derivatives
  </Card>
</div>

<Warning>Availability may vary by region and liquidity</Warning>

## Network Expansion

<Note>
  Rampnow continuously expands blockchain coverage based on:

  * Partner and customer demand
  * Network stability and maturity
  * Liquidity provider support
</Note>

**Request a new chain or token:**
Contact our team to discuss adding support for specific assets or networks.

<div>
  <Card title="Contact Sales" icon="envelope" href="https://rampnow.io/en/list#list-token-form">
    Reach out via our Contact & Support page
  </Card>

  <Card title="Email Us" icon="paper-plane">
    Send details to `admin@rampnow.io`
  </Card>
</div>

## Real-time explorer

Use the explorer below to browse supported tokens and chains pulled directly from our API.

# Supported Assets

<TokenExplorer />


# Onramp Overview
Source: https://docs.rampnow.io/quickstart/onramp/onramp

Convert fiat to digital assets across a wide range of blockchains with a single, unified API

Rampnow delivers a high-conversion fiat-to-digital-asset onramp used by top Web3 applications across multiple regions. Users can buy assets without leaving your app, while Rampnow manages payment routing and token delivery behind the scenes.

<Note>
  Rampnow's onramp infrastructure enables seamless fiat-to-crypto conversion with enterprise-grade reliability and global payment coverage.
</Note>

## Why choose Rampnow?

<div>
  <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** across all regions
  </Card>

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

## Core Capabilities

### <Icon icon="chart-line" /> Instant Quotes

Get accurate, deterministic pricing with:

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

### <Icon icon="wallet" /> Global Payment Acceptance

Support for multiple payment methods:

* **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

Optimized asset delivery with:

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

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

Multi-layer protection including:

* Device fingerprinting
* Behavioral risk scoring
* Payment fraud checks
* Beneficiary wallet screening

## Use Cases

<div>
  <Card title="Wallets" icon="wallet">
    Enable direct asset purchases from within mobile or browser wallets for seamless user experience.
  </Card>

  <Card title="Exchanges" icon="exchange">
    Support instant fiat deposits into digital asset accounts with automated settlement.
  </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 features to banking and neobank applications.
  </Card>

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

## Developer Experience

<Steps>
  <Step title="Quick Integration">
    Choose your integration method:

    * **Widget**: Embed in minutes with minimal code
    * **API**: Full customization with REST endpoints
    * **SDK**: Native integration for your platform
  </Step>

  <Step title="Test & Deploy">
    * Use sandbox keys for testing
    * Access integration examples
    * Monitor with webhooks for all events
  </Step>

  <Step title="Go Live">
    * Instant onboarding process
    * Real-time monitoring dashboard
    * Dedicated support team
  </Step>
</Steps>

<Tip>
  Read our [**API Specification**](/api-reference/overview)
</Tip>

***

## Next Steps

<div>
  <Card title="Onramp Flow" icon="arrow-progress" href="/quickstart/onramp/onramp-flow">
    Understand the step-by-step purchase journey
  </Card>

  <Card title="Supported Assets" icon="coins" href="/quickstart/onramp/chains-and-tokens">
    View all supported blockchains and tokens
  </Card>

  <Card title="Integration Guide" icon="code" href="/api-reference/overview">
    Start building with widget, API, or SDK
  </Card>
</div>


# Onramp Flow
Source: https://docs.rampnow.io/quickstart/onramp/onramp-flow

Step-by-step overview of the complete fiat-to-digital-asset purchase journey

<Info>
  This guide walks through the complete user journey from quote generation to token delivery. Each step is managed by Rampnow's infrastructure to ensure security and conversion optimization.
</Info>

<Frame>
  <img alt="Quote generation interface" />
</Frame>

## Complete Purchase Journey

<Steps>
  <Step title="Quote Generation" icon="calculator">
    The client requests a quote with purchase parameters.

    <Frame>
      <img alt="Quote generation interface" />
    </Frame>

    **Request includes:**

    * Fiat currency
    * Payment method
    * Token & blockchain
    * Purchase amount

    **Rampnow returns:**

    * Total cost breakdown
    * Network fees
    * Payment processing fees
    * Token amount to receive

    <Tip>Quotes are deterministic and guaranteed upon checkout</Tip>
  </Step>

  <Step title="Wallet Address Input" icon="wallet">
    User provides the destination wallet address.

    <Frame>
      <img alt="Quote generation interface" />
    </Frame>

    **Address validation checks:**

    * ✓ Correct blockchain network
    * ✓ Account Abstraction
    * ✓ Valid checksum format
    * ✓ Contract restrictions
    * ✓ Valid address format

    <Note>Users can manually enter an address or connect their wallet directly</Note>
  </Step>

  <Step title="Email & OTP Verification" icon="envelope">
    Security verification to prevent fraud and ensure account validity.

    <Frame>
      <img alt="Email and OTP verification" />
    </Frame>

    **Verification process:**

    1. User enters email address
    2. OTP code sent to email
    3. User submits OTP
    4. Session validated and secured
  </Step>

  <Step title="Payment Processing" icon="credit-card">
    User completes payment using their preferred method.

    <Frame>
      <img alt="Payment method selection" />
    </Frame>

    **Supported payment methods:**

    <Tabs>
      <Tab title="Cards">
        * Visa
        * Mastercard
          <Tip>Instant processing</Tip>
      </Tab>

      <Tab title="Bank Transfers">
        * SEPA (EU)
        * ACH (US)
        * PIX (Brazil)
        * UPI (India)
        * SPEI (Mexico)
        * Khipu (Chile)
      </Tab>

      <Tab title="Digital Wallets">
        * Apple Pay
        * Google Pay
        * Cash App (US)
        * Local APMs
      </Tab>
    </Tabs>

    <Info>
      See the [Payment Methods & Limits](/quickstart/onramp/payment-methods) page for the full, live list of active payment rails by country.
    </Info>

    **Status updates via:**

    * Real-time webhooks
    * API polling
  </Step>

  <Step title="Settlement" icon="building-columns">
    Funds are settled and crypto is prepared for delivery.

    <Frame>
      <img alt="Payment method selection" />
    </Frame>

    **Settlement process:**

    1. Payment confirmation received
    2. Funds settle to banking partners
    3. Routing engine triggers liquidity movement
    4. Crypto assets prepared for blockchain delivery

    <Info>Settlement times vary by payment method (instant to 1-3 business days)</Info>
  </Step>

  <Step title="Token Delivery" icon="paper-plane">
    Tokens are delivered to the user's wallet address.

    <Frame>
      <img alt="Token delivery to wallet" />
    </Frame>

    **Delivery process:**

    1. Transaction broadcast to blockchain
    2. Network confirmation
    3. Transaction hash generated
    4. Final delivery confirmation
  </Step>

  <Check>Transaction complete! Users can track their tokens on the blockchain explorer.</Check>
</Steps>

***

## Order statuses

You track an onramp order through these statuses (delivered on every change via [webhooks](/api-reference/webhook), or by polling the order):

* `created` → order created, awaiting payment
* `processing` → payment received; crypto being settled on-chain to the user
* `completed` → crypto delivered to the destination wallet (success)
* `failed` → a settlement attempt failed — **not terminal**; Rampnow re-settles, so it can still reach `completed`
* `payment_failed` → the user's payment failed/declined (terminal — a retry needs a new order)
* `expired` / `canceled` → order not paid in time / canceled (terminal)
* `blocked` → blocked by KYT screening or refunded (terminal)

See the full [status table](/api-reference/webhook) for meanings and which are terminal.

## Flow Characteristics

<div>
  <Card title="Consistent" icon="check-double">
    Same experience across all regions and payment methods
  </Card>

  <Card title="Optimized" icon="gauge-high">
    High conversion rates with minimal friction
  </Card>
</div>

***

## Integration Options

<div>
  <Card title="Widget Integration" icon="window" href="/api-reference/widget-mode">
    Embed the complete flow with minimal code
  </Card>

  <Card title="API Integration" icon="code" href="/api-reference/hosted-mode">
    Build custom flows with full control
  </Card>
</div>

***

## Next Steps

<Steps>
  <Step title="Review API Documentation">
    Learn how to implement each step programmatically
  </Step>

  <Step title="Test in Sandbox">
    Use test credentials to simulate the complete flow
  </Step>

  <Step title="Handle Webhooks">
    Set up event listeners for real-time status updates
  </Step>
</Steps>

<Card title="Ready to integrate?" icon="rocket" href="/api-reference/overview">
  Start with our Integration guide
</Card>


# Payment Methods & Limits
Source: https://docs.rampnow.io/quickstart/onramp/payment-methods

Overview of cards, bank transfers and local payment methods supported by Rampnow

<Note>
  **Configurable limits** — Transaction limits vary by region, payment method and user verification level. Contact support for custom limit configurations.
</Note>

<Card title="Skip to Payment Explorer" icon="arrow-down" href="#payment-explorer">
  Jump directly to the interactive payment methods table to search and filter by region and flow type.
</Card>

Rampnow supports global card processing, local APMs and regional bank transfers for **onramp** (buy). Limits and availability vary by region and method.

<Note>
  This page covers **onramp** methods. For the full onramp + offramp matrix see [Payment Methods & Limits](/quickstart/resources/payment-methods). The interactive explorer below is the source of truth — the static lists are illustrative.
</Note>

<div>
  <Card title="Global Card Coverage" icon="credit-card">
    Visa, Mastercard, Apple Pay and Google Pay in **120+ countries** with multi-currency support and risk-adjusted limits.
  </Card>

  <Card title="Local APMs & Bank Transfers" icon="building-columns">
    PIX, UPI, SEPA, ACH, QR-based wallets and local bank rails across Europe, Americas, APAC and LATAM.
  </Card>

  <Card title="Configurable Limits" icon="sliders">
    Per-transaction, and per day limits tuned by method, currency and risk profile.
  </Card>
</div>

## Payment Method Categories

<Tabs>
  <Tab title="Card Payments">
    ### Global Card Coverage (Onramp)

    Rampnow processes card payments globally through Visa, Mastercard, Apple Pay and Google Pay with support for **120+ countries**.

    **Supported currencies:** EUR, USD, GBP, AUD, CHF, JPY, PLN, TRY, SGD, HKD, VND, DKK, SEK, NOK, NZD, ZAR, SAR, RON, AED, KRW.

    Per-transaction minimum and maximum limits are configured per currency and payment method and are returned live by the config API (`paymentModeConfigs` in `GET /ext/ramp_order/config`). Daily velocity limits depend on the user's verification level; contact support for your account's configuration.

    <Info>
      Exact availability depends on card issuer, 3DS/SCA requirements and regional regulations.
    </Info>
  </Tab>

  <Tab title="Bank Transfers & APMs">
    ### Local Payment Methods (Onramp)

    Region-specific payment methods optimized for local user preferences and banking infrastructure.

    **Europe:**

    * EU: SEPA bank transfer, SEPA open banking

    **Asia/Pacific:**

    * India: UPI, IMPS, NEFT
    * Philippines: QR Ph
    * Indonesia: Bank transfer
    * UAE: Bank transfer

    **LATAM:**

    * Brazil: PIX
    * Mexico: Bank transfer
    * Chile: Bank transfer
    * Colombia: Bank transfer
    * Argentina: Bank transfer

    **Africa:**

    * Nigeria: Bank transfer

    **North America:**

    * USA: ACH, Wire, Cash App

    <Info>
      This list reflects payment rails currently active in production. See the [Interactive Payment Explorer](#payment-explorer) below for the live, always-current view.
    </Info>
  </Tab>
</Tabs>

<Warning>
  Payment method availability changes by region and over time, so the lists above are illustrative. Always check the **current** supported status programmatically via the config API — [`GET /ext/ramp_order/config`](/api-reference/configuration/getramporderconfig) (`paymentModeConfigs`) — which is the source of truth for what is enabled for your account.
</Warning>

## Understanding Limits

Higher KYC verification unlocks higher per-transaction and cumulative (velocity) limits. These are the current caps by verification level, pulled live from the config API:

<KycLimitsTable />

<AccordionGroup>
  <Accordion title="Transaction Limits" icon="money-bill">
    Minimum and maximum amounts per single transaction, enforced at the payment processor level.
  </Accordion>

  <Accordion title="Daily Limits" icon="calendar-day">
    Rolling day limit calculated from the current transaction backwards. Resets continuously as older transactions age out.
  </Accordion>

  <Accordion title="Custom Limits" icon="gear">
    Enterprise partners can request custom limit configurations based on their use case.
  </Accordion>
</AccordionGroup>

<Warning>
  Limits may be adjusted based on user verification level and transaction history.
</Warning>

## Need Custom Limits or New Payment Methods?

<Card title="Contact Support" icon="envelope">
  For custom limit configurations or to request support for additional payment methods, reach out to our team at **[admin@rampnow.io](mailto:admin@rampnow.io)**

  Include details about your use case, expected transaction volumes and target regions.
</Card>

## Interactive Payment Explorer

<div>
  <PaymentMethodsExplorer />
</div>


# Supported Blockchains
Source: https://docs.rampnow.io/quickstart/resources/blockchain-list

Browse all blockchains supported by Rampnow, grouped by product

<Note>
  **Real-time data** — This list is generated directly from the live Rampnow configuration API and updates automatically as new blockchains are added or removed.
</Note>

Rampnow supports a wide range of blockchain networks for onramp and offramp flows. Each blockchain listed here has at least one active product route—either **Onramp** (buy) or **Offramp** (sell)—based on real-time configuration from our production routing engine.

## What's Included

This list includes all blockchains where Rampnow has active, production-ready routes.

<AccordionGroup>
  <Accordion title="Major L1 Networks" icon="layer-group">
    Leading layer-1 blockchains including Ethereum, Bitcoin, Solana, Avalanche, Tron, BNB Chain and more.
  </Accordion>

  <Accordion title="L2 Networks" icon="bolt">
    Scaling solutions like Arbitrum, Optimism, Base, zkSync, Polygon PoS, Linea and other layer-2 networks.
  </Accordion>

  <Accordion title="Ecosystem Chains" icon="network-wired">
    Specialized networks including Kava, Fantom, Aurora, Cronos, Harmony and ecosystem-specific chains.
  </Accordion>

  <Accordion title="Emerging Blockchains" icon="rocket">
    New and emerging blockchains integrated through Rampnow's routing layer based on partner demand or institutional requirements.
  </Accordion>
</AccordionGroup>

<Warning>
  Chains without active buy/sell routes do not appear until they are fully enabled in production.
</Warning>

## Data Sources & Updates

This page uses live data from Rampnow's routing configuration API, ensuring accuracy and real-time updates.

<div>
  <Card title="Automatic Updates" icon="rotate">
    Newly supported chains appear automatically once activated in production.
  </Card>

  <Card title="Real-Time Status" icon="signal">
    Chains temporarily disabled due to liquidity or infrastructure issues are hidden immediately.
  </Card>

  <Card title="Live Token Counts" icon="hashtag">
    Token counts update instantly when assets are added or removed from any blockchain.
  </Card>

  <Card title="Zero Maintenance" icon="check">
    No manual updates required—partners always see real-time network coverage.
  </Card>
</div>

<Tip>
  Partners always see the real-time network coverage powering both Rampnow's widget and API.
</Tip>

## Need Support for a New Chain?

Want Rampnow to add a blockchain that's not currently listed? We're always evaluating new networks based on demand and feasibility.

### What to Include in Your Request

<div>
  <Card title="Chain Details" icon="link">
    * Chain name
    * Chain ID
    * RPC endpoints
  </Card>

  <Card title="Token Information" icon="coins">
    * Native token details
    * Token contract addresses (if applicable)
  </Card>
</div>

Our routing and liquidity teams will review feasibility and provide integration timelines.

<div>
  <Card title="Contact Sales" icon="envelope" href="https://rampnow.io/en/list#list-token-form">
    Reach out via our Contact & Support page
  </Card>

  <Card title="Email Us" icon="paper-plane">
    Send details to `admin@rampnow.io`
  </Card>
</div>

<Note>
  Integration timelines vary based on technical complexity, liquidity availability and regulatory requirements for each blockchain.
</Note>

## Supported Blockchains

<div>
  <ChainExplorer />
</div>


# Payment Methods & Limits
Source: https://docs.rampnow.io/quickstart/resources/payment-methods

Overview of cards, bank transfers and local payment methods supported by Rampnow

<Note>
  **Configurable limits** — Transaction limits vary by region, payment method and user verification level. Contact support for custom limit configurations.
</Note>

<Card title="Skip to Payment Explorer" icon="arrow-down" href="#payment-explorer">
  Jump directly to the interactive payment methods table to search and filter by region and flow type.
</Card>

Rampnow supports global card processing, local APMs, and regional bank transfers for **onramp** (buy) flows, while **offramp** (sell) flows are currently limited to EUR via SEPA bank transfers. Limits and availability vary by region and method.

<div>
  <Card title="Global Card Coverage" icon="credit-card">
    Visa, Mastercard, Apple Pay and Google Pay in **120+ countries** with multi-currency support and risk-adjusted limits.
  </Card>

  <Card title="Local APMs & Bank Transfers" icon="building-columns">
    PIX, UPI, QR Ph, Cash App, and local bank rails across North America, Europe, APAC, LATAM, and Africa.
  </Card>

  <Card title="Configurable Limits" icon="sliders">
    Per-transaction and daily limits tuned by method, currency and risk profile.
  </Card>
</div>

## Payment Method Categories

<Tabs>
  <Tab title="Card Payments">
    ### Global Card Coverage (Onramp)

    Rampnow processes card payments globally through Visa, Mastercard, Apple Pay and Google Pay with support for **120+ countries**.

    **Supported currencies:** EUR, USD, GBP, AUD, CHF, JPY, PLN, TRY, SGD, HKD, VND, DKK, SEK, NOK, NZD, ZAR, SAR, RON, AED, KRW.

    Per-transaction minimum and maximum limits are configured per currency and payment method and are returned live by the config API — see the interactive explorer below, or `paymentModeConfigs` in `GET /ext/ramp_order/config`. Daily velocity limits depend on the user's verification level; contact support for your account's configuration.

    <Info>
      Exact availability depends on card issuer, 3DS/SCA requirements and regional regulations.
    </Info>
  </Tab>

  <Tab title="Bank Transfers & APMs">
    ### Local Payment Methods (Onramp)

    Region-specific payment methods optimized for local user preferences and banking infrastructure.

    **Europe:**

    * EU: SEPA bank transfer, SEPA open banking

    **Asia/Pacific:**

    * India: UPI, IMPS, NEFT
    * Philippines: QR Ph
    * Indonesia: Bank transfer
    * UAE: Bank transfer

    **LATAM:**

    * Brazil: PIX
    * Mexico: Bank transfer
    * Chile: Bank transfer
    * Colombia: Bank transfer
    * Argentina: Bank transfer

    **Africa:**

    * Nigeria: Bank transfer

    **North America:**

    * USA: ACH, Wire, Cash App
  </Tab>

  <Tab title="Offramp Payouts">
    ### Bank Payout Methods (Offramp)

    Sell crypto and receive fiat directly to your bank account.

    | Region                                                          | Method             | Currency                  | Status   |
    | --------------------------------------------------------------- | ------------------ | ------------------------- | -------- |
    | EU (27 states)                                                  | SEPA bank transfer | EUR                       | **Live** |
    | United Kingdom, India, Philippines, Indonesia, Vietnam and more | Local bank rails   | GBP, INR, PHP, IDR, VND … | Roadmap  |

    <Note>
      Offramp is currently **live for EUR via SEPA**. Other corridors are on the roadmap — the live [payment explorer](#interactive-payment-explorer) always reflects what is actually enabled for your account.
    </Note>
  </Tab>
</Tabs>

## Understanding Limits

Higher KYC verification unlocks higher per-transaction and cumulative (velocity) limits. These are the current caps by verification level, pulled live from the config API:

<KycLimitsTable />

<AccordionGroup>
  <Accordion title="Transaction Limits" icon="money-bill">
    Minimum and maximum amounts per single transaction, enforced at the payment processor level.
  </Accordion>

  <Accordion title="Daily Limits" icon="calendar-day">
    Rolling day limit calculated from the current transaction backwards. Resets continuously as older transactions age out.
  </Accordion>

  <Accordion title="Custom Limits" icon="gear">
    Enterprise partners can request custom limit configurations based on their use case.
  </Accordion>
</AccordionGroup>

<Warning>
  Limits may be adjusted based on user verification level and transaction history.
</Warning>

## Need Custom Limits or New Payment Methods?

<Card title="Contact Support" icon="envelope">
  For custom limit configurations or to request support for additional payment methods, reach out to our team at **[admin@rampnow.io](mailto:admin@rampnow.io)**

  Include details about your use case, expected transaction volumes and target regions.
</Card>

## Interactive Payment Explorer

<div>
  <PaymentMethodsExplorer />
</div>


# Supported Assets
Source: https://docs.rampnow.io/quickstart/resources/supported-assets

Browse all supported tokens and blockchains in Rampnow

<Note>
  **Real-time data** — This list is generated directly from the live Rampnow configuration API and updates automatically as new assets are added or removed.
</Note>

## What's Included

<AccordionGroup>
  <Accordion title="Onramp-enabled tokens" icon="arrow-down">
    Assets that can be purchased with fiat via Rampnow using cards, bank transfers and local payment methods (availability varies by region).
  </Accordion>

  <Accordion title="Offramp-enabled tokens" icon="arrow-up">
    Assets that can be sold for fiat and paid out to supported payout methods in your region.
  </Accordion>

  <Accordion title="Multi-chain assets" icon="network-wired">
    If a token is available on multiple blockchains, you'll see a separate entry per chain. For example, `USDT` appears separately for Ethereum, Arbitrum, Polygon and other supported networks.
  </Accordion>
</AccordionGroup>

<Info>
  Only tokens with at least one active product configuration (Onramp or Offramp) are shown. Internal test assets, disabled assets, or temporarily paused routes are not listed.
</Info>

## Live Updates & Coverage

The asset list automatically reflects production changes:

* ✅ **New tokens and blockchains** appear automatically once activated
* ❌ **Paused or removed tokens** disappear from the list immediately
* 📊 **Token and blockchain counts** at the top always show current coverage

<Warning>
  Token availability may vary by region due to regulatory requirements and liquidity constraints.
</Warning>

## Missing a Token or Chain?

Need support for a specific asset that's not listed?

<div>
  <Card title="Contact Sales" icon="envelope" href="https://rampnow.io/en/list#list-token-form">
    Reach out via our Contact & Support page
  </Card>

  <Card title="Email Us" icon="paper-plane">
    Send details to `admin@rampnow.io`
  </Card>
</div>

**What to include in your request:**

* Token symbol and name
* Contract address
* Target blockchain
* Use case or integration timeline

<Tip>
  Our team reviews all requests based on demand and liquidity availability. We'll respond with integration timelines and next steps.
</Tip>

# Supported Assets

<TokenExplorer />


# Supported Countries
Source: https://docs.rampnow.io/quickstart/resources/supported-countries

List of all supported, restricted and prohibited countries for using Rampnow services

<Note>
  **Global coverage** — Rampnow provides services across 120+ countries. Availability depends on card networks and local banking rails.
</Note>

Rampnow provides global coverage for **onramp** and **offramp** flows. The list below outlines all countries where Rampnow services are available, followed by restricted and prohibited jurisdictions.

<Info>
  If a country is not listed under *Prohibited* or *Restricted*, it is considered **supported** for Rampnow services.
</Info>

## How Country Classification Works

<div>
  <Card title="Supported Countries" icon="circle-check">
    Fully eligible for all Rampnow services, subject to payment method availability.
  </Card>

  <Card title="Restricted Countries" icon="triangle-exclamation">
    Limited availability. Additional review may be required for onboarding and operations.
  </Card>

  <Card title="Prohibited Countries" icon="circle-xmark">
    No services available. Rampnow does not onboard customers or process payments from these jurisdictions.
  </Card>
</div>

<Warning>
  Payment method availability may vary by region. See our [Payment Methods & Limits](/quickstart/resources/payment-methods) page for detailed coverage.
</Warning>

<div />

## Country Status

<Tabs>
  <Tab title="Supported Countries">
    ### Fully Supported Countries

    These countries are fully eligible for Rampnow services, subject to payment method availability.

    <AccordionGroup>
      <Accordion title="Europe (40+ countries)" icon="earth-europe">
        Andorra, Austria, Belgium, Bosnia and Herzegovina, Croatia, Cyprus, Czech Republic, Denmark, Estonia, Faroe Islands, Finland, France, Germany, Gibraltar, Greece, Greenland, Guernsey, Hungary, Iceland, Ireland, Isle of Man, Italy, Jersey, Latvia, Liechtenstein, Lithuania, Luxembourg, Malta, Montenegro, Netherlands, Norway, Poland, Portugal, Romania, San Marino, Slovakia, Slovenia, Spain, Sweden, Switzerland, United Kingdom
      </Accordion>

      <Accordion title="Asia & Pacific (25+ countries)" icon="earth-asia">
        Armenia, Australia, Azerbaijan, Bahrain, Bhutan, Brunei, Fiji, Georgia, Hong Kong, India, Indonesia, Israel, Japan, Jordan, Kazakhstan, Kuwait, Kyrgyzstan, Macau, Malaysia, Micronesia, Mongolia, New Zealand, Oman, Papua New Guinea, Philippines, Qatar, Saudi Arabia, Singapore, South Korea, Sri Lanka, Taiwan, Thailand, Turkey, United Arab Emirates, Uzbekistan, Vietnam
      </Accordion>

      <Accordion title="Americas (15+ countries)" icon="earth-americas">
        Argentina, Aruba, Bahamas, Barbados, Belize, Bermuda, Brazil, Chile, Colombia, Costa Rica, Curaçao, Dominican Republic, Ecuador, El Salvador, Guyana, Mexico, Panama, Paraguay, Peru, United States, Uruguay
      </Accordion>

      <Accordion title="Africa (5+ countries)" icon="earth-africa">
        Kenya, Mauritius, Rwanda, South Africa, Zambia
      </Accordion>
    </AccordionGroup>

    <Tip>
      Payment methods and limits vary by region. Check the [Payment Methods & Limits](/quickstart/resources/payment-methods) page for specific availability in your country.
    </Tip>
  </Tab>

  <Tab title="Restricted Countries">
    ### Restricted Jurisdictions

    Rampnow maintains **limited availability** for customers or partners based in these jurisdictions. Any onboarding, operational activity, or integration may require additional review and approval.

    <AccordionGroup>
      <Accordion title="Africa (30+ countries)" icon="earth-africa">
        Algeria, Angola, Benin, Burkina Faso, Cameroon, Chad, Congo (Republic of), Côte d'Ivoire, Djibouti, Egypt, Equatorial Guinea, Eritrea, Eswatini, Gabon, Gambia, Ghana, Guinea, Guinea-Bissau, Liberia, Madagascar, Mauritania, Morocco, Mozambique, Namibia, Niger, Nigeria, Senegal, Sierra Leone, Sudan, Tanzania, Togo, Tunisia, Uganda
      </Accordion>

      <Accordion title="Asia & Pacific (10+ countries)" icon="earth-asia">
        Bangladesh, Cambodia, China, Iraq, Kosovo, Nepal, Pakistan, Timor-Leste, Tokelau, Tonga, Tuvalu, Vanuatu
      </Accordion>

      <Accordion title="Americas (6+ countries)" icon="earth-americas">
        Bolivia, Canada, French Guiana, Guatemala, Haiti, Honduras, Nicaragua, Trinidad and Tobago
      </Accordion>

      <Accordion title="Europe (5+ countries)" icon="earth-europe">
        Bonaire Sint Eustatius and Saba, Bulgaria, Moldova, North Macedonia, Serbia, Ukraine
      </Accordion>
    </AccordionGroup>

    <Info>
      If you're operating from a restricted country and need to integrate Rampnow, contact our team at **[admin@rampnow.io](mailto:admin@rampnow.io)** for approval.
    </Info>
  </Tab>

  <Tab title="Prohibited Countries">
    ### Prohibited Jurisdictions

    Rampnow **does not** onboard customers, process payments, or establish any business relationships with users or entities from the following jurisdictions, regardless of currency or payment method.

    <Warning>
      This restriction applies to **all services** . These restrictions apply globally and without exception.
    </Warning>

    **Complete list of prohibited countries:**

    * Afghanistan
    * American Samoa
    * Belarus
    * Burundi
    * Central African Republic
    * Congo (Democratic Republic)
    * Cuba
    * Crimea region of Ukraine
    * Donetsk People's Republic
    * Guam
    * Iran
    * North Korea
    * Lebanon
    * Libya
    * Luhansk People's Republic
    * Mali
    * Myanmar
    * Northern Mariana Islands
    * Puerto Rico
    * Russian Federation
    * Somalia
    * South Sudan
    * Syria
    * United States Minor Outlying Islands
    * U.S. Virgin Islands
    * Venezuela
    * Yemen
    * Zimbabwe

    <Note>
      This list is subject to change.
    </Note>
  </Tab>
</Tabs>

## Regional Payment Method Availability

Different payment methods are available depending on your country and region.

<div>
  <Card title="Card Payments" icon="credit-card">
    **Available in:** 120+ countries globally

    Visa, Mastercard, Apple Pay and Google Pay with multi-currency support.
  </Card>

  <Card title="Bank Transfers & APMs" icon="building-columns">
    **Available in:** EU, UK, APAC, LATAM, Africa

    **Supported:** Apple Pay, Google Pay, SEPA, PIX, UPI, ACH, and other local banking rails.
  </Card>
</div>

<Tip>
  For detailed payment method coverage by country, visit the [Payment Methods & Limits](/quickstart/resources/payment-methods) page.
</Tip>

## Need Support or Expansion?

Have questions about country availability or need to request expansion to a new jurisdiction?

<div>
  <Card title="Verify Availability" icon="circle-question" href="https://rampnow.io/en/contact-us">
    Contact us to verify service availability for a specific region.
  </Card>

  <Card title="Request Expansion" icon="globe" href="https://rampnow.io/en/list#list-token-form">
    Submit a request for expansion to a new jurisdiction. We'll review feasibility.
  </Card>
</div>

**We can provide:**

* Local payment method coverage details
* FX and settlement restrictions by region
* Integration timelines for new markets

<Card title="Contact Support" icon="envelope">
  **Email:** [admin@rampnow.io](mailto:admin@rampnow.io)

  Include your country and use case in your inquiry.
</Card>

<Note>
  Country classifications and restrictions are subject to change. This page is updated regularly to reflect current availability.
</Note>