> This page is for Internet banking (beta).

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://en.docs.api.corpx.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://en.docs.api.corpx.com/_mcp/server.

# Read P2P market parameters

GET https://client.api.corpx.com/v1/p2p/settings

Read-only market parameters a customer needs before the first order: deadlines, the per-order cap that applies to this tenant (the lower of the market cap and the tenant cap), the advertiser fee range across levels and the enabled pairs. Nothing here is per account; the order shows the exact fee before the PIN. Off for every tenant until CorpX enables `p2p_crypto` (`403 feature_disabled`).


Reference: https://en.docs.api.corpx.com/ib/referencia/p-2-p/get-p-2-p-settings

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Request

### Headers

- `X-Tenant-Id` (string, required) — Tenant context used for authorization and routing.
- `X-Request-Timestamp` (string, required) — Unix seconds. Required on the signed host; tolerance is 300s either way (`403 request_timestamp_skew`).
- `X-Content-SHA256` (string, required) — Lowercase hex SHA-256 of the body. An empty body hashes the empty string, so the header is always present. Mismatch returns `400 body_hash_mismatch`.
- `X-Request-Signature` (string, required) — Detached JWS (`<protected>..<signature>`, ES256 or PS256) over `METHOD\nPATH?QUERY\nTIMESTAMP\nIDEMPOTENCY_KEY_OR_EMPTY\nX_CONTENT_SHA256`.

## Response

### 200

Market parameters

- `signingDeadlineMin` (integer, optional) — Minutes both parties have to sign the order contract.
- `deliveryMinMin` (integer, optional) — Shortest delivery deadline an advertiser may promise, in minutes.
- `deliveryMaxMin` (integer, optional) — Longest delivery deadline an advertiser may promise, in minutes.
- `releaseDeadlineH` (integer, optional) — Hours the buyer has to release the BRL after the crypto is confirmed on-chain.
- `walletChangeGraceH` (integer, optional) — Hours a newly registered wallet waits before it can be used.
- `orderCap` (string, optional, nullable) — Per-order cap in BRL for this tenant (lower of market and tenant caps). Null when no cap is set.
- `dailyCap` (string, optional, nullable) — Daily cap in BRL for this tenant. Null when no cap is set.
- `feeBpsMin` (integer, optional, nullable) — Lowest advertiser fee across levels, in basis points. Null when no level is configured.
- `feeBpsMax` (integer, optional, nullable) — Highest advertiser fee across levels, in basis points. Null when no level is configured.
- `pairs` (list of P2PSettingsPairsItems, optional) — Enabled pairs (code, asset, network).

## Errors

### 403 Forbidden Error

`feature_disabled`.

- `errorCode` (string, required) — Stable machine-readable code. See `ErrorCode` for the known values.
- `message` (string, required) — Human-readable explanation (pt-BR). Presentation only; may change.
- `docs` (string, optional) — Link to this code in the public error catalogue.
- `requestId` (string, optional) — Gateway request id. Quote it when contacting support.
- `details` (map from string to any, optional) — Optional machine-readable context for the specific `errorCode` (for example `kind` on `identity_verification_monthly_limit_exceeded`, `maxBytes` on `payload_too_large`, `attemptsRemaining` on `facetec_attempts_exhausted`). Keys are documented per operation; absent when the code carries no extra context.
- `partner` (ErrorResponsePartner, optional) — Raw error from the settlement bank, when the failure came from it. Diagnostic only.

## Types

### P2PSettingsPairsItems

- `code` (string, optional) — Pair code.
- `asset` (string, optional) — Asset.
- `network` (string, optional) — Network.

### ErrorResponsePartner

Raw error from the settlement bank, when the failure came from it. Diagnostic only.

- `code` (string, optional)
- `message` (string, optional)
- `field` (string, optional) — Field the partner pointed at, when any.

## Examples

**Response**

```json
{
  "signingDeadlineMin": 15,
  "deliveryMinMin": 5,
  "deliveryMaxMin": 30,
  "releaseDeadlineH": 24,
  "walletChangeGraceH": 18,
  "orderCap": "100000.00",
  "dailyCap": null,
  "feeBpsMin": 5,
  "feeBpsMax": 8,
  "pairs": [
    {
      "code": "USDT_TRON",
      "asset": "USDT",
      "network": "TRON"
    }
  ]
}
```

**SDK Code**

```python P2P_getP2PSettings_example
import requests

url = "https://client.api.corpx.com/v1/p2p/settings"

headers = {
    "X-Content-SHA256": "X-Content-SHA256",
    "X-Request-Signature": "X-Request-Signature",
    "X-Request-Timestamp": "X-Request-Timestamp",
    "X-Tenant-Id": "X-Tenant-Id",
    "Authorization": "Bearer <token>"
}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript P2P_getP2PSettings_example
const url = 'https://client.api.corpx.com/v1/p2p/settings';
const options = {
  method: 'GET',
  headers: {
    'X-Content-SHA256': 'X-Content-SHA256',
    'X-Request-Signature': 'X-Request-Signature',
    'X-Request-Timestamp': 'X-Request-Timestamp',
    'X-Tenant-Id': 'X-Tenant-Id',
    Authorization: 'Bearer <token>'
  }
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go P2P_getP2PSettings_example
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://client.api.corpx.com/v1/p2p/settings"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("X-Content-SHA256", "X-Content-SHA256")
	req.Header.Add("X-Request-Signature", "X-Request-Signature")
	req.Header.Add("X-Request-Timestamp", "X-Request-Timestamp")
	req.Header.Add("X-Tenant-Id", "X-Tenant-Id")
	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby P2P_getP2PSettings_example
require 'uri'
require 'net/http'

url = URI("https://client.api.corpx.com/v1/p2p/settings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["X-Content-SHA256"] = 'X-Content-SHA256'
request["X-Request-Signature"] = 'X-Request-Signature'
request["X-Request-Timestamp"] = 'X-Request-Timestamp'
request["X-Tenant-Id"] = 'X-Tenant-Id'
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java P2P_getP2PSettings_example
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://client.api.corpx.com/v1/p2p/settings")
  .header("X-Content-SHA256", "X-Content-SHA256")
  .header("X-Request-Signature", "X-Request-Signature")
  .header("X-Request-Timestamp", "X-Request-Timestamp")
  .header("X-Tenant-Id", "X-Tenant-Id")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php P2P_getP2PSettings_example
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://client.api.corpx.com/v1/p2p/settings', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'X-Content-SHA256' => 'X-Content-SHA256',
    'X-Request-Signature' => 'X-Request-Signature',
    'X-Request-Timestamp' => 'X-Request-Timestamp',
    'X-Tenant-Id' => 'X-Tenant-Id',
  ],
]);

echo $response->getBody();
```

```csharp P2P_getP2PSettings_example
using RestSharp;

var client = new RestClient("https://client.api.corpx.com/v1/p2p/settings");
var request = new RestRequest(Method.GET);
request.AddHeader("X-Content-SHA256", "X-Content-SHA256");
request.AddHeader("X-Request-Signature", "X-Request-Signature");
request.AddHeader("X-Request-Timestamp", "X-Request-Timestamp");
request.AddHeader("X-Tenant-Id", "X-Tenant-Id");
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift P2P_getP2PSettings_example
import Foundation

let headers = [
  "X-Content-SHA256": "X-Content-SHA256",
  "X-Request-Signature": "X-Request-Signature",
  "X-Request-Timestamp": "X-Request-Timestamp",
  "X-Tenant-Id": "X-Tenant-Id",
  "Authorization": "Bearer <token>"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://client.api.corpx.com/v1/p2p/settings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```