Paradigm API v1

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

API Connection URLs

The API is available on Paradigm's Test and Live environments.

Live

RESToverHTTP: https://api.chat.paradigm.co/
JSON-RPCoverWebSocket: wss://ws.api.chat.paradigm.co/

Test

RESToverHTTP: https://api.test.paradigm.co/
JSON-RPCoverWebSocket: wss://ws.api.test.paradigm.co/

Rate Limits

RESToverHTTP requests are rate limited to 10 requests per second per desk across all API Keys.

This means you cannot horizontally scale your rate limit per desk by using multiple API Keys. Each desk has a collective rate limit of 10 requests per second.

Implementation Paths

This section will describe in brief detail the expected solution implementation paths, best practices when using the Paradigm API as well some colour around onboarding.

High Level

You should use your connection to Paradigm through JSON-RPCoverWebsockets to receive updates relating to RFQs, Quotes, and Trades.

You should use our RESToverHTTP endpoints to interact with Paradigm for all actions such as, but not limited to, Creating RFQs, Creating Quotes, Canceling Quotes.

As a Taker, you should expect to hit/lift the full quantity of your RFQ. At the present moment it is not possible to only hit/lift a partial amount.

As a Maker, you should expect to Quote the full quantity of each leg of the RFQ. At the present moment it is not possible to Quote only part of the leg's quantity in the RFQ.

Your solution should:

For JSON-RPCoverWebSocket Connections, ensure a heartbeat has be initiated and is being maintained.
Ensure each request has the neccessary authentication attributes as each request must be authenticated.
Be subscribed to the rfq, quote, trade, and trade_confirmation JSON-RPCoverWebSockets Notification channels to receive updates relating to those events.
Wait for responses to RESToverHTTP requests to confirm successful or erroneous interactions.
As a Maker, ensure you /quote/cancel/ before attempting to Quote an RFQ again with /quote/create/.
Ensure you receive confirmation on the trade_confirmation JSON-RPCoverWebSockets Notification channel that a trade has been successfully completed.

Your solution should not:

Use RESToverHTTP endpoints to frequently request updates relating to RFQs, Quotes or Trades.
Send /quote/create/ to update Quotes. Please /quote/cancel/ and then /quote/create/.
Use JSON-RPCoverWebSockets to send requests to Paradigm.

Onboarding

We can create as many Paradigm test environment accounts as you like. We would love to create a Taker and a Maker account, functionally no different to each other, so you test the workflow end-to-end.

For test environment accounts, all you need to do is: - Contact your Sales representative with your account creation request. - Provide a unique email address for each Paradigm test account as well as the First and Last Name to be associated. - Upon creation, enter testnet Exchange API credentials to the Paradigm test environment account.

Exchange Testnet URLs

Deribit's Testnet: test.deribit.com
Bit.com's Testnet: beta.bitexch.dev

Helpful Reminders

You CANNOT RFQ or Quote yourself.
All instruments on Paradigm are the same instruments you trade on the underlying exchange. This means:
- You must submit your RFQ & Quote pricing to match the instrument specification's minimum tick size.
- You must submit your RFQ & Quote quantity to match the instrument specification's minimum order size.

API Workflows

Taker's Perspective

Important Note: Both the Taker and the Maker will receive all updates through the JSON-RPCoverWebSockets Notification channels for events relating to RFQs, Quotes, and Trades.

Taker creates an RFQ using /rfq/create/. You can pull available instruments from GET /instruments/ and counterparties from GET /counterparties/.
Taker is able to cancel an RFQ if they wish to do so with /rfq/cancel/.
Maker, who is a requested counterparty to the RFQ, and is notified over the rfq JSON-RPCoverWebSockets Notification channel, is then able to provide a quote to the RFQ.
Taker, who will be notified of quotes on the quote JSON-RPCoverWebSockets Notification channel, is able to execute upon the quote of their choice using with /quote/execute/.
Taker, will receive confirmation of the trade's completion on the trade_confirmation JSON-RPCoverWebSockets Notification channel.
Taker, will also receive confirmation of the trade being completed on the trade JSON-RPCoverWebSockets Notification channel as well as all other trades on Paradigm.

We have Auto-Market Makers running on our Test environment. You are able to request any RFQ from them and they will respond with a number of quotes promptly.

Their desk names are "DSK2", "DSK3", "DSK4", "DSK5", and "MT2". They are apart of the 'LP' counterparty list returned from GET /counterparties/.

Maker's Perspective

Important Note: Both the Taker and the Maker will receive all updates through the JSON-RPCoverWebSockets Notification channels for events relating to RFQs, Quotes, and Trades.

Taker will create an RFQ and the Maker will be notified on the rfq JSON-RPCoverWebSockets Notification channel.
Maker is able to create a one way quote using /quote/create/.
Maker is able to cancel an existing quote with /quote/cancel/. A Maker must cancel any existing quote on an RFQ before they are able to update their quote.
Taker, chooses to /quote/execute/ an existing quote.
Maker, will receive confirmation of the trade's completion on the trade_confirmation JSON-RPCoverWebSockets Notification channel.
Maker, will receive confirmation of the trade being completed on the trade JSON-RPCoverWebSockets Notification channel as well as all other trades on Paradigm.

Code Examples

Reach out if you ever need any help! We are more than happy to help.

You will need to update the provided Code Examples with your own Paradigm Access Key and Secret Key.

You can find all existing examples on our github: https://github.com/tradeparadigm/code-samples

Note: All examples in this section are in Python3.

JSON-RPCoverWebSockets

Authenticate, establish a heartbeat and Subscribe to the rfq, quote, trade, and trade_confirmation JSON-RPCoverWebSockets Notification Channels.

RESToverHTTP

All Interactions

Takers and Makers should both be subscribed to the rfq, quote, trade, and trade_confirmation JSON-RPCoverWebsockets Notification channels to receive the required information to use the RESToverHTTP endpoints.

Both Makers and Takers

POST - /echo/ - A simple code example demonstrating how to have the server respond with your requested message.
GET - /instruments/ - A simple code example demonstrating how to pull the instruments available on Paradigm.
GET - /counterparties/ - A simple code example demonstrating how to pull your available counterparties' information.
GET - /rfq/ - A simple code example demonstrating how to pull information relating to RFQs you were aparty to.
GET - /rfq/ - A more comprehensive example demonstrating pagination and the use of parameters.

Taker Specific

POST - /rfq/create/ - A simple code example demonstrating how to create an RFQ.
POST - /rfq/cancel/ - A simple code example demonstrating how to cancel an RFQ.
POST - /quote/execute/ - A simple code example demonstrating how to execute a provided Quote.

Maker Specific

POST - /quote/create/ - A simple code example demonstrating how to create a Quote.
POST - /quote/cancel/ - A simple code example demonstrating how to cancel an already created Quote.

Auto-Market Makers

We have Auto-Market Makers running on our Test environment. You are able to request any RFQ from them and they will respond with a number of quotes promptly.

The desk names of the Auto-Marker Makers are "DSK2", "DSK3", "DSK4", "DSK5", and "MT2" on the Test environment.

If you would like to run your own Auto-Market Maker, here is a link to the code and dockerfile: https://github.com/tradeparadigm/code-samples/tree/main/api/market_maker

Auto-Takers

We also have Auto-Taker code examples to help Maker's test their solutions.

Auto-Taker-Creator - Creates RFQs every 5 seconds: https://github.com/tradeparadigm/code-samples/tree/main/api/auto_taker
Auto-Taker-Executor - Executes the best received quote every 5 seconds: https://github.com/tradeparadigm/code-samples/tree/main/api/market_taker

Errors

All REST error responses follow the same basic format. An Error object is returned in response to an erroneous RESToverHTTP request, accompanied by a HTTP status code of 400.

Specific error codes are listed with each RESToverHTTP endpoint.

Error Object

An example of an erroneous Response message

{
    "code": 1002,
    "message": "Invalid enumeration set value",
    "data": {
        "member": "side",
        "value": "CROSS"
    }
}

The Error object is expressed as a single JSON Object, with the following members:

Member	Type	Req	Description
code	number	Y	The type of error that occured.
message	string	Y	A short description of the error.
data	object	N	Additional structured information about the error. The value is determined by the specific member invoked and may not be present if the error does not require it.

Error Codes

The following general error codes are supported by Paradigm:

Code	Message	Meaning
-32700	Parse error	Invalid JSON received by the server.
-32600	Invalid Request	The JSON sent is not a valid Request object.
-32601	Method not found	The method does not exist / is not available.
-32602	Invalid params	Invalid method parameter(s).
-32603	Internal error	Internal JSON-RPC error.
429	Desk's ratelimit reached. Expected available in 1 second.	The rate limit is 10 requests per second.
1001	Insufficient permissions	The user does not have sufficient permissions to execute the method.
1002	Invalid enumeration set value	The enumeration set value is invalid for the specified field.

Authentication

All Paradigm API endpoints are considered private and require authentication.

Paradigm uses token-based authentication for API access to both the RESToverHTTP and JSON-RPCoverWebSocket APIs.

As an additional protection measure against replay attacks in environments where SSL trust is not properly configured, Paradigm requires all HTTP requests to be signed using a secret key.

Important Notes:

Paradigm does not currently provide fine-grained token scopes or permissions. Please ensure your API credentials are stored securely.
If you have an IP whitelist set for your Deribit API Keys, on Deribit, you will need to remove this or ask for Paradigm's environment IP addresses.

There are a number of Authentication methods available across both the RESToverHTTP and JSON-RPCoverWebSocket protocols, these include: - Token-based Authentication - HTTP Header - Cookie - Query String Parameter (JSON-RPCoverWebSocket only)

Error Codes

The following error codes relate to Authentication Errors:

Code	Message	Meaning
401	API Key is not enabled or has been revoked.	Paradigm API Key is Inactive or has been Deleted.
401	Invalid API Access Key.	Paradigm API Access Key is invalid or incorrect.
403	Request signature verification failed.	Paradigm API Secret Key is invalid or incorrect.

Generating a Paradigm API Key

Before accessing any RESToverHTTP or JSON-RPCoverWebSocket API endpoints, you must generate the necessary Paradigm API credentials. This can be accomplished via the Paradigm Admin Dashboard.

Live Environment

Paradigm Admin Dashboard URL: https://admin.chat.paradigm.co/

Test Environment

Paradigm Admin Dashboard URL: https://admin.test.paradigm.co/

Once Created:

When you have generated Paradigm API credentials, you will be presented with two keys:

Access Key: used to authenticate the API.
Secret Key: used to sign requests against the API.

Be sure to save these two keys somewhere secure as both the Access Key and the Secret Key will only be visible once during creation.

If you lose either the Access Key or the Secret Key, you will need to generate a new Paradigm API Key via the admin dashboard.

Token-based Authentication

Only the Access Key is needed for authenticating requests. The different methods are presented below in order of our preference.

In all examples, replace <access-key> with your Paradigm API Key's Access Key generated from your admin dashboard during creation.

HTTP Header

Authorization example with a HTTP Header

{
    "Authorization": "Bearer SXDlhLKYX6GH6InhBxcCzoW4"
}

When possible, authentication should be performed using the Authorization HTTP header. The header should supply the Paradigm API Access Key in plain text, preceded by the text "Bearer ".

Authorization: Bearer <access-key>

In some cases, providing custom HTTP headers may not be possible. This is particularly true when connecting to JSON-RPCoverWebSockets via browser APIs.

In these cases, the Paradigm API Key Access Key may be provided by a special HTTP cookie. The cookie should be defined as follows:

Paradigm-API-Key = <access-key>

Query String Parameter (for JSON-RPCoverWebSocket connections only)

In the unlikely scenario that you are unable to use HTTP headers or Cookies for authentication against the JSON-RPCoverWebSocket API, Paradigm supports a special HTTP query parameter.

The query parameter can be provided as part of the WebSocket connection URL.

Live URL Example

JSON-RPCoverWebSocket Connection URL: wss://ws.api.chat.paradigm.co/?api-key=<access-key>

Test URL Example

JSON-RPCoverWebSocket Connection URL: wss://ws.api.test.paradigm.co/?api-key=<access-key>

Signing Requests

Paradigm requires all RESToverHTTP requests to be signed.

GET RESToverHTTP example demonstrating signing of requests

# A GET RESToverHTTP sample demonstrating the generation of signatures and signing of requests.

import base64
import hmac
import json
import time
from urllib.parse import urljoin

import requests


def sign_request(secret_key, method, path, body):
    signing_key = base64.b64decode(secret_key)

    timestamp = str(int(time.time() * 1000)).encode('utf-8')
    message = b'\n'.join([timestamp, method.upper(), path, body])
    digest = hmac.digest(signing_key, message, 'sha256')
    signature = base64.b64encode(digest)

    return timestamp, signature


access_key = '<ACCESS-KEY>'
secret_key = '<SECRET-KEY>' 
host = 'https://api.test.paradigm.co'

# GET example
method = b'GET'
path = b'/instruments/'
body = b''

timestamp, signature = sign_request(secret_key, method, path, body)
headers = {
    'Authorization': 'Bearer {}'.format(access_key),
    'Paradigm-API-Timestamp': timestamp,
    'Paradigm-API-Signature': signature,
}
url = urljoin(host, path.decode())
response = requests.get(url, headers=headers)
print(response.status_code)
print(response.text)

POST RESToverHTTP example demonstrating signing of requests

# A POST RESToverHTTP sample demonstrating the generation of signatures and signing of requests.

import base64
import hmac
import json
import time
from urllib.parse import urljoin

import requests


def sign_request(secret_key, method, path, body):
    signing_key = base64.b64decode(secret_key)

    timestamp = str(int(time.time() * 1000)).encode('utf-8')
    message = b'\n'.join([timestamp, method.upper(), path, body])
    digest = hmac.digest(signing_key, message, 'sha256')
    signature = base64.b64encode(digest)

    return timestamp, signature


access_key = '<ACCESS-KEY>'
secret_key = '<SECRET-KEY>' 
host = 'https://api.test.paradigm.co'

# POST example
method = b'POST'
path = b'/echo/'
data = {'message': 'hello'}
body = json.dumps(data).encode('utf-8')

timestamp, signature = sign_request(secret_key, method, path, body)
headers = {
    'Authorization': 'Bearer {}'.format(access_key),
    'Paradigm-API-Signature': signature,
    'Paradigm-API-Timestamp': timestamp,
    'Accept': 'application/json',
}
url = urljoin(host, path.decode())
response = requests.post(url, headers=headers, json=data)
print(response.status_code)
print(response.text)

Important Note: Signing is not currently supported for JSON-RPCoverWebSocket API endpoints.

Request signatures are generated by applying the HMAC-SHA256 function to the Secret Key and a concatenated message consisting of the request timestamp, request method, request path, query parameters, and body. The key provided to the HMAC function must be the base64-decoded version of the Secret Key. The signature must then be base64-encoded and passed via a special header value.

Some important considerations are:

The timestamp must be a UNIX timestamp (seconds since epoch in UTC).
The request method must be capitalized (e.g. GET).
The request path must include the entire base path of the request (e.g. /rfq/).
The request parameters must include ? (e.g. ?cursor=a2Ed&venue=DBT) unless none are used.
The request body should be substituted with an empty string for GET requests

Once the signature is generated, the timestamp and signature should be provided as HTTP headers:

Header Name	Header Value
Paradigm-API-Signature	The generated signature
Paradigm-API-Timestamp	The timestamp used when generating the signature

Note: Signed requests are only valid for 30 seconds from when the timestamp is captured. Requests received after the 30 second window are rejected.

JSON-RPC over WebSocket

JSON-RPC

JSON-RPC is a stateless, light-weight remote procedure call (RPC) protocol. It uses JSON (RFC 4627) as the data format.

All member names exchanged between the Client and the Server that are considered for matching of any kind should be considered to be case-sensitive.The Client is defined as the origin of Request objects and the handler of Response objects. The Server is defined as the origin of Response objects and the handler of Request objects. A trader using the API can fill the role of both the Client and the Server depending on the Request.

Error Codes

The following error codes relate to establishing a JSON-RPCoverWebSocket connection:

Code	Message	Meaning
HTTP 403	websockets.exceptions.InvalidStatusCode: server rejected WebSocket connection: HTTP 403	An invalid or incorrect Paradigm API Access Key was used to authenticate the JSON-RPCoverWebSocket connection.
HTTP 403	websockets.exceptions.InvalidStatusCode: server rejected WebSocket connection: HTTP 403	Incorrect connection query string used.

Cancel on Disconnect

Cancel on Disconnect mode is enabled on all JSON-RPCoverWebSocket connections by default. Cancel on Disconnect mode will cancel all outstanding RFQs and Quotes that have been sent with the API Key used to authenticate the WebSocket session when the WebSocket connection disconnects.

If multiple WebSocket connections are concurrently authenticated with the same API Key, then RFQs and Quotes will only be canceled when the last connection with Cancel on Disconnect mode enabled disconnects.

To disable cancel on disconnect mode, specify cancel_on_disconnect=false as a query string parameter when connecting to the WebSocket endpoint.

Live Cancel on Disconnect Example

JSON-RPCoverWebSocket Connection URL: wss://ws.api.chat.paradigm.co/?cancel_on_disconnect=false

Test Cancel on Disconnect Example

JSON-RPCoverWebSocket Connection URL: wss://ws.api.test.paradigm.co/?cancel_on_disconnect=false

Request Objects

An example of a JSON-RPCoverWebSocket Request message

{
    "id": "1",
    "jsonrpc": "2.0",
    "method": "subscribe",
    "params": {
        "channel": "rfq"
    }
}

A RPC call is represented by sending a Request object to a Server.

The Request object has the following members:

Member	Type	Req	Description
id	string or number	N	An identifier established by the Client. The id is omitted if the method is a Notification.
jsonrpc	string	Y	The version of the JSON-RPC protocol. Always "2.0".
method	string	Y	The name of the method to be invoked.
params	object	N	The parameter values to be used during the invocation of the method. This field may be omitted if the method has no parameters.

Response Objects

An example of a Successful Response message

{
    "id": "1",
    "jsonrpc": "2.0",
    "result": [
        "rfq",
        "trade"
    ]
}

An example of an Erroneous Response message

{
    "id": "1",
    "jsonrpc": "2.0",
    "error": {
        "code": -32601,
        "message": "method not found",
        "data": {
           "method": "unsubscribe-all",
           "timestamp": 1597326842.415
        }
    }
}

When a RPC call is made, the Server replies with a Response, except for in the case of Notifications. The Response is expressed as a single JSON Object, with the following members:

Member	Type	Req	Description
id	string or number	N	The same value of the id field specified on the Request object. The value is null if there is an error parsing the Request object. The value is omitted in a Notification.
jsonrpc	string	Y	The version of the JSON-RPC protocol. Always "2.0".
result	object	N	The result of a successful request. The value is determined by the specific method invoked. Not present if there is an erroneous result.
error	Error object	N	The result of an erroneous request. Not present if there is a successful result.
> code	number	N	Error code.
> message	string	N	Error message.
> data	object	N	Array of information relating to error.
>> method	string	N	Erroneous request method.
>> timestamp	decimal	N	The time the error occurred as the number of milliseconds since epoch (January 1, 1970).

Session Methods

heartbeat

An example of a JSON-RPCoverWebSocket heartbeat Request Object

{
    "id": 1,
    "jsonrpc": "2.0",
    "method": "heartbeat"
}

An example of a JSON-RPCoverWebSocket heartbeat Response Object

{
    "id": 1,
    "jsonrpc": "2.0"
}

The client is required to regularly send heartbeat Requests to the user over a WebSocket connection at least once every 10 seconds.

If the user does not send a heartbeat in a given 10 second window, the WebSocket connection will be closed by Paradigm.

Paradigm will respond to a heartbeat Request with a heartbeat Response.

Note: The Request does not have a params object and the Response does not have a results object.

Error Codes

The following error code relates to maintaining a heartbeat:

Code	Message	Meaning
4005	websockets.exceptions.ConnectionClosedError: code = 4005 (private use), no reason	The WebSocket connection did not receive a heartbeat request within the past 10 seconds.

Subscription Methods

Subscriptions work as Notifications, so users will automatically (after subscribing) receive messages from the server.

They are the primary means through which you should intend to receive updates with regards to RFQs, Quotes, and Trades.

Subscriptions are only available through WebSockets as these are sent asynchronously from Paradigm to the user as they happen.

Subscription Notification objects have the following members:

Member	Type	Req	Description
jsonrpc	string	Y	Always "2.0".
method	string	Y	Always "subscription".
params	object	Y	Array of returned data.
> channel	string	Y	The name of the channel.
> data	object	Y	Data specific to the channel.

An example of a subscribe Request Object

{
   "id": 123,
   "jsonrpc": "2.0",
   "method": "subscribe",
   "params": {
            "channel": "rfq"
   }
}

An example of a subscribe Response Object

{
    "id": 123,
    "jsonrpc": "2.0",
    "result": [
               "rfq",
               "trade"
    ]
}

There are four subscription channels you can subscribe to: rfq, quote, trade, and trade_confirmation.

To subscribe to multiple channels, send a separate subscribe request for each channel.

Note: The Response result is a JSON array of all channels currently subscribed to.

The Request params object has the following members:

Member	Type	Req	Description
channel	string	Y	The channel to subscribe to.
data	object	N	An channel-specific object that specifies parameters for the channel.

unsubscribe

An example of an unsubscribe Request Object

{
   "id": 123,
   "jsonrpc": "2.0",
   "method": "unsubscribe",
   "params": {
      "channels": [
                  "rfq"
      ]
   }
}

An example of an unsubscribe Response Object

{
   "id": 123,
   "jsonrpc": "2.0",
   "result": [
            "trade"     
   ]
}

To unsubscribe from multiple channels, send a separate unsubscribe request for each channel.

Note: The Response result is a JSON array of all channels currently subscribed to.

The Request params object has the following members:

Member	Type	Req	Description
channel	string	Y	The channel to unsubscribe from.

Notification Channels

A Notification is a Request object without an id member. A Request object that is a Notification signifies the Client's lack of interest in the corresponding Response object, and as such no Response object needs to be returned to the client. The Server must not reply to a Notification, including those that are within a batch request.

Notifications are not confirmable by definition, since they do not have a Response object to be returned. As such, the Client would not be aware of any errors (like e.g. "Invalid params", "Internal error").

The Notification Channels are the primary means by which your solution should be expected to be updated with regards to RFQs, Quotes, and Trades.

rfq

An example, as the Taker, of the rfq notification received when an RFQ is created

{
   "jsonrpc":"2.0",
   "method":"subscription",
   "params":{
      "channel":"rfq",
      "data":{
         "created":1611022135830.395,
         "desk":"DSK2",
         "rfq_id":22523,
         "account":{
            "name":"ParadigmTestTwo"
         },
         "client_order_id":"",
         "legs":[
            {
               "instrument":"BTC-19JAN21-32000-C",
               "quantity":25.0,
               "side":"SELL",
               "venue":"DBT"
            },
            {
               "instrument":"BTC-20JAN21-36000-C",
               "quantity":25.0,
               "side":"BUY",
               "venue":"DBT"
            }
         ],
         "status":"ACTIVE",
         "valid_until":1611108535827.299,
         "stream":false,
         "counterparties":[
            "DSK1",
            "DSK3",
            "DSK4",
            "DSK5"
         ]
      }
   }
}

An example, as the Taker, of the rfq notification received when an RFQ is canceled

{
   "jsonrpc":"2.0",
   "method":"subscription",
   "params":{
      "channel":"rfq",
      "data":{
         "created":1611022135830.395,
         "desk":"DSK2",
         "rfq_id":22523,
         "account":{
            "name":"ParadigmTestTwo"
         },
         "client_order_id":"",
         "legs":[
            {
               "instrument":"BTC-19JAN21-32000-C",
               "quantity":25.0,
               "side":"SELL",
               "venue":"DBT"
            },
            {
               "instrument":"BTC-20JAN21-36000-C",
               "quantity":25.0,
               "side":"BUY",
               "venue":"DBT"
            }
         ],
         "status":"CANCELED",
         "valid_until":1611108535827.299,
         "stream":false,
         "counterparties":[
            "DSK1",
            "DSK3",
            "DSK4",
            "DSK5"
         ]
      }
   }
}

An example, as the Taker, of the rfq notification received when an RFQ is filled

{
   "jsonrpc":"2.0",
   "method":"subscription",
   "params":{
      "channel":"rfq",
      "data":{
         "created":1611023461827.417,
         "desk":"DSK2",
         "rfq_id":22527,
         "account":{
            "name":"ParadigmTestTwo"
         },
         "client_order_id":"",
         "legs":[
            {
               "instrument":"BTC-19JAN21-32000-C",
               "quantity":25.0,
               "side":"BUY",
               "venue":"DBT"
            }
         ],
         "status":"FILLED",
         "valid_until":1611023489464.3481,
         "stream":false,
         "counterparties":[
            "DSK1",
            "DSK3",
            "DSK4",
            "DSK5"
         ]
      }
   }
}

An example, as the Maker, of the rfq notification received when an RFQ is created

{
   "jsonrpc":"2.0",
   "method":"subscription",
   "params":{
      "channel":"rfq",
      "data":{
         "created":1611022135830.395,
         "desk":"DSK2",
         "rfq_id":22523,
         "legs":[
            {
               "instrument":"BTC-19JAN21-32000-C",
               "quantity":25.0,
               "side":"SELL",
               "venue":"DBT"
            },
            {
               "instrument":"BTC-20JAN21-36000-C",
               "quantity":25.0,
               "side":"BUY",
               "venue":"DBT"
            }
         ],
         "status":"ACTIVE",
         "valid_until":1611108535827.299,
         "stream":false
      }
   }
}

An example, as the Maker, of the rfq notification received when an RFQ is canceled

{
   "jsonrpc":"2.0",
   "method":"subscription",
   "params":{
      "channel":"rfq",
      "data":{
         "created":1611022135830.395,
         "desk":"DSK2",
         "rfq_id":22523,
         "legs":[
            {
               "instrument":"BTC-19JAN21-32000-C",
               "quantity":25.0,
               "side":"SELL",
               "venue":"DBT"
            },
            {
               "instrument":"BTC-20JAN21-36000-C",
               "quantity":25.0,
               "side":"BUY",
               "venue":"DBT"
            }
         ],
         "status":"CANCELED",
         "valid_until":1611108535827.299,
         "stream":false
      }
   }
}

An example, as the Maker, of the rfq notification received when an RFQ is filled

{
   "jsonrpc":"2.0",
   "method":"subscription",
   "params":{
      "channel":"rfq",
      "data":{
         "created":1611023461827.417,
         "desk":"DSK2",
         "rfq_id":22527,
         "legs":[
            {
               "instrument":"BTC-19JAN21-32000-C",
               "quantity":25.0,
               "side":"BUY",
               "venue":"DBT"
            }
         ],
         "status":"FILLED",
         "valid_until":1611023489464.3481,
         "stream":false
      }
   }
}

An update to an RFQ sent as an RFQ object with members the user is permissioned for. Users are sent RFQs in which they are a counterparty to.

Each RFQ has a globally unique identifier with the rfq_id member.

The most recently received Notification with the same rfq_id is the current state of the RFQ.

Important Note: Quotes in response to the RFQs are not sent through the rfq notifications channel, but through the quote notifications channel.

The response "params" data object has the following members:

Member	Type	Req	Description
channel	string	Y	The notification channel the message was delivered upon.
data	array	Y	An arrary of information relating to the specific RFQ.
> created	decimal	Y	The time the RFQ was created in the number of milliseconds since epoch (January 1, 1970).
> desk	string	N	The Desk Name of Taker.
> rfq_id	number	Y	The unique identifier of the RFQ. Paradigm creates this value.
> account	object	N	An array present as the Taker detailing the Paradigm API Key Name or "CME" related information.
>> name	string	N	Name of the Paradigm API Key used.
>> clearing_account_name	string	N	Clearing Account Name related to trades executed upon the "CME".
>> trader_id	string	N	Trader ID related to trades executed upon the "CME".
> client_order_id	string	Y	User determined unique identifier. Empty if the RFQ is created using the GUI.
> legs	array of objects	Y	An array of instruments that comprise the RFQ.
>> instrument	string	Y	None
>> price	decimal	N	The price of the leg if specified.
>> quantity	decimal	Y	The number of contracts of the leg.
>> venue	string	Y	The venue the RFQ will be executed on.
> status	string	Y	The status of the RFQ. Values can include: `ACTIVE`, `CANCELED`, `FILLED`.
> stream	bool	Y	If the RFQ is an RFS stream.
> counterparties	[strings]	N	As the Taker, the other counterparties involved in the RFQ.
> valid_until	decimal	N	The time the RFQ expires in the number of milliseconds since epoch (January 1, 1970).

quote

An example, as the Taker, of the quote notification received when a Quote is created

{
   "jsonrpc":"2.0",
   "method":"subscription",
   "params":{
      "channel":"quote",
      "data":{
         "desk":"DSK1",
         "valid_until":1611024209158.0242,
         "created":1611024112328.771,
         "legs":[
            {
               "price":0.1294,
               "quantity":25.0,
               "instrument":"BTC-19JAN21-32000-C",
               "side":"SELL",
               "venue":"DBT"
            },
            {
               "price":0.0302,
               "quantity":25.0,
               "instrument":"BTC-20JAN21-36000-C",
               "side":"BUY",
               "venue":"DBT"
            }
         ],
         "quote_id":84032,
         "rfq_id":22530,
         "side":"SELL",
         "status":"ACTIVE"
      }
   }
}

An example, as the Taker, of the quote notification received when a Quote is canceled

{
   "jsonrpc":"2.0",
   "method":"subscription",
   "params":{
      "channel":"quote",
      "data":{
         "desk":"DSK1",
         "valid_until":"None",
         "created":1611024112328.771,
         "legs":[
            {
               "price":"None",
               "quantity":25.0,
               "instrument":"BTC-19JAN21-32000-C",
               "side":"SELL",
               "venue":"DBT"
            },
            {
               "price":"None",
               "quantity":25.0,
               "instrument":"BTC-20JAN21-36000-C",
               "side":"BUY",
               "venue":"DBT"
            }
         ],
         "quote_id":84032,
         "rfq_id":22530,
         "side":"SELL",
         "status":"CANCELED"
      }
   }
}

An example, as the Taker, of the quote notification received when a Quote is executed

{
   "desk":"DSK2",
   "valid_until":1616995320247.1162,
   "created":1616995218247.1162,
   "legs":[
      {
         "instrument":"BTC-PERPETUAL",
         "price":55084.4,
         "quantity":20000.0,
         "side":"BUY",
         "venue":"DBT"
      }
   ],
   "quote_id":1541710,
   "rfq_id":244484,
   "side":"SELL",
   "status":"PENDING_FILL"
}

An example, as the Maker, of the quote notification received when a Quote is created

{
   "jsonrpc":"2.0",
   "method":"subscription",
   "params":{
      "channel":"quote",
      "data":{
         "desk":"DSK1",
         "valid_until":1611024209158.0242,
         "account":{
            "name":"ParadigmTestOne"
         },
         "client_order_id":"DSK1738007604",
         "created":1611024112328.771,
         "legs":[
            {
               "price":0.1294,
               "quantity":25.0,
               "instrument":"BTC-19JAN21-32000-C",
               "side":"SELL",
               "venue":"DBT"
            },
            {
               "price":0.0302,
               "quantity":25.0,
               "instrument":"BTC-20JAN21-36000-C",
               "side":"BUY",
               "venue":"DBT"
            }
         ],
         "quote_id":84032,
         "rfq_id":22530,
         "side":"SELL",
         "status":"ACTIVE"
      }
   }
}

An example, as the Maker, of the quote notification received when a Quote is canceled

{
   "jsonrpc":"2.0",
   "method":"subscription",
   "params":{
      "channel":"quote",
      "data":{
         "desk":"DSK1",
         "valid_until":"None",
         "account":{
            "name":"ParadigmTestOne"
         },
         "client_order_id":"DSK1738007604",
         "created":1611024112328.771,
         "legs":[
            {
               "price":"None",
               "quantity":25.0,
               "instrument":"BTC-19JAN21-32000-C",
               "side":"SELL",
               "venue":"DBT"
            },
            {
               "price":"None",
               "quantity":25.0,
               "instrument":"BTC-20JAN21-36000-C",
               "side":"BUY",
               "venue":"DBT"
            }
         ],
         "quote_id":84032,
         "rfq_id":22530,
         "side":"SELL",
         "status":"CANCELED"
      }
   }
}

An example, as the Maker, of the quote notification received when a Quote is filled

{
   "desk":"DSK2",
   "valid_until":1616995442399.624,
   "account":{
      "name":"ParadigmTestTwo"
   },
   "client_order_id":"DSK2572194009",
   "created":1616995359399.624,
   "legs":[
      {
         "instrument":"BTC-PERPETUAL",
         "price":55063.79,
         "quantity":20000.0,
         "side":"BUY",
         "venue":"DBT"
      }
   ],
   "quote_id":1541712,
   "rfq_id":244485,
   "side":"SELL",
   "status":"PENDING_FILL"
}

An update to a Quote sent in response to an RFQ sent as a Quote object with members the user is permissioned for. Users are sent quotes in which they are a counterparty to.

Each Quote has a globally unique identifier with the quote_id member.

The most recently received Notification with the same quote_id is the current state of the RFQ & Quote.

As Takers, you are able to see all Quotes provided to you and the desk name of the counterparty.

As Makers, you are only able to see your Quote and the desk name of the Taker if the RFQ is on a disclosed basis.

Note: You will not receive an EXPIRED Quote notification message.

The response params data object has the following members:

Member	Type	Req	Description
channel	string	Y	The channel name the message was received upon.
data	array	Y	An array containing information relating to the Quote(s) of a specific RFQ.
> desk	string	N	The Paradigm desk name of the Taker.
> valid_until	decimal	Y	The time at which the Quote expires in the number of milliseconds since epoch (January 1, 1970).
> created	decimal	Y	The time the Quote was executed in the number of milliseconds since epoch (January 1, 1970).
> legs	array of objects	Y	An array of legs that comprise the RFQ.
>> price	decimal	Y	The price of the leg if one is quoted
>> quantity	decimal	Y	The quantity of the leg if one is quoted.
>> side	string	Y	The direction of the leg. Values can be `BUY` and `SELL`.
>> venue	string	Y	The venue which the RFQ will be executed upon.
> price	decimal	N	The calculated spread price, if applicable.
> quote_id	string	Y	The unique identifier of the Quote. Paradigm creates this value.
> rfq_id	string	Y	The unique identifier of the RFQ. Paradigm creates this value.
> side	string	Y	None

trade

An example, as the Taker or the Maker, of the trade notification received when a trade is completed

{
   "created":1616995466611.969,
   "legs":[
      {
         "instrument":"BTC-PERPETUAL",
         "price":54608.22,
         "quantity":20000.0,
         "venue":"DBT",
         "trade_id":44290
      }
   ],
   "price":54608.22,
   "quote_id":1541713,
   "rfq_id":244486
}

Trades are sent for all executions on the Paradigm platform after the trade is confirmed by the Exchange.

The response params data object has the following members:

Member	Type	Req	Description
channel	string	Y	The channel upon which the notification was delivered.
data	array	Y	An array of information relating to the completed Trade of the RFQ.
> created	decimal	Y	The time the Trade was executed in the number of milliseconds since epoch (January 1, 1970).
> legs	array of objects	Y	An array of legs that comprise the RFQ.
>> instrument	string	Y	None
>> price	decimal	Y	The price of the leg.
>> quantity	decimal	Y	The number of contracts of the leg.
>> venue	string	Y	The venue the RFQ was executed on.
>> trade_id	decimal	Y	The unique identifier of the trade. Paradigm determines this.
> price	decimal	N	The calculated spread price, if applicable.
> quote_id	string	Y	The unique identifier of the Quote executed. Paradigm determines this.
> rfq_id	string	Y	The unique identifier of the RFQ executed. Paradigm determines this.

trade_confirmation

An example, as the Taker or the Maker, of the trade_confirmation notification received when a trade is completed

{
   "account":{
      "name":"ParadigmTestTwo"
   },
   "created":1616995466611.969,
   "desk":"DSK2",
   "exec_id":"68454170",
   "instrument":"BTC-PERPETUAL",
   "venue":"DBT",
   "price":54608.22,
   "quantity":20000.0,
   "side":"BUY",
   "quote_id":1541713,
   "rfq_id":244486,
   "trade_id":44290
}

Trade Confirmations are sent for executions the user is involved in when the Exchange confirms the Trade.

Trade Confirmations are published for each individual leg executed.

The Request params data object has the following members:

Member	Type	Req	Description
channel	string	Y	The notification channel the message was received upon.
data	array	Y	An array of trade confirmation information relating to a specific RFQ.
> account	object	N	An array present as the Taker detailing the Paradigm API Key Name or "CME" related information.
>> name	string	N	Name of the Paradigm API Key used.
>> clearing_account_name	string	N	Clearing Account Name related to trades executed upon the "CME".
>> trader_id	string	N	Trader ID related to trades executed upon the "CME".
> created	decimal	Y	The time the instrument was executed at the exchange in the number of milliseconds since epoch (January 1, 1970).
> desk	string	Y	The Paradigm Desk Name involved in the trade (your API Key's desk).
> exec_id	string	N	Venue-specific field. The venue's unique identifier for the trade. The venue determines this value.
> instrument	string	Y	The instrument name executed.
> venue	string	Y	The venue the trade was executed on.
> price	number	Y	The execution price of the instrument name.
> quantity	number	Y	The number of contracts executed.
> side	string	Y	The direction of the trade. Valid values can include "BUY" and "SELL".
> quote_id	string	Y	The unique identifier for the quote that corresponds to the trade. Paradigm determines this value.
> rfq_id	string	Y	The unique identifier for the RFQ that corresponds to the trade. Paradigm determines this value.
> trade_id	string	Y	The unique identifier for the trade that corresponds to the trade. Paradigm determines this value.

Platform REST Endpoints

/echo/ [POST]

/echo/ Request example

# You can also use wget
curl -X POST https://api.chat.paradigm.co/echo/ \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer ACCESS_KEY'

const inputBody = '{
  "message": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer ACCESS_KEY'
};

fetch('https://api.chat.paradigm.co/echo/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

# built ins
import base64
import hmac
import time
from urllib.parse import urljoin
import json

# installed
import requests


access_key = '<access-key>'
secret_key = '<secret-key>'

signing_key = base64.b64decode(secret_key)

print('Paradigm Account Access Key: {}'.format(access_key))
print('Paradigm Account Secret Key: {}'.format(signing_key))

# Request Body

host = 'https://api.test.paradigm.co'

# POST /echo/
method = 'POST'
path = '/echo/'

body = b''

payload = {
            "message": "this is a test echo message"
            }

json_payload = json.dumps(payload).encode('utf-8')

message = method.encode('utf-8') + b'\n'
message += path.encode('utf-8') + b'\n'
message += json_payload

timestamp = str(int(time.time() * 1000))
message = timestamp.encode('utf-8') + b'\n' + message
digest = hmac.digest(signing_key, message, 'sha256')
signature = base64.b64encode(digest)


headers = {
            'Paradigm-API-Timestamp': timestamp,
            'Paradigm-API-Signature': signature,
            'Authorization': f'Bearer {access_key}'
            }

# Send request
response = requests.post(urljoin(host, path),
                         headers=headers,
                         json=payload)

print(response.status_code)
print(response.text)

package main

import (
       "bytes"
       "net/https"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer ACCESS_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := https.NewRequest("POST", "http://api.chat.paradigm.co/echo/", data)
    req.Header = headers

    client := &https.Client{}
    resp, err := client.Do(req)
    // ...
}

/echo/ Response example

{
  "message": "this is a test echo message"
}

A POST /echo/ request returns the message specified in the request. It is designed for users to test the signing of requests.

Parameters

Name	In	Type	Required	Description
body	body	object	true	none
message	body	string	false	none

Responses

Status	Meaning	Description	Schema
200	OK	echoed request body	None

/instruments/ [GET]

/instruments/ Request example

# You can also use wget
curl -X GET https://api.chat.paradigm.co/instruments/ \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer ACCESS_KEY'


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer ACCESS_KEY'
};

fetch('https://api.chat.paradigm.co/instruments/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


# built ins
import base64
import hmac
import time
from urllib.parse import urljoin
import json

# installed
import requests


access_key = '<access-key>'
secret_key = '<secret-key>'

signing_key = base64.b64decode(secret_key)

print('Paradigm Account Access Key: {}'.format(access_key))
print('Paradigm Account Secret Key: {}'.format(signing_key))

# Request Body

host = 'https://api.test.paradigm.co'

# GET /instruments/
method = 'GET'
path = '/instruments/?venue=DBT&'

body = b''

message = method.encode('utf-8') + b'\n'
message += path.encode('utf-8') + b'\n'

timestamp = str(int(time.time() * 1000))
message = timestamp.encode('utf-8') + b'\n' + message
digest = hmac.digest(signing_key, message, 'sha256')
signature = base64.b64encode(digest)


headers = {
            'Paradigm-API-Timestamp': timestamp,
            'Paradigm-API-Signature': signature,
            'Authorization': f'Bearer {access_key}'
            }

# Send request
response = requests.get(urljoin(host, path),
                        headers=headers)

print(response.status_code)
print(response.text)

package main

import (
       "bytes"
       "net/https"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer ACCESS_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := https.NewRequest("GET", "http://api.chat.paradigm.co/instruments/", data)
    req.Header = headers

    client := &https.Client{}
    resp, err := client.Do(req)
    // ...
}

A GET /instruments/ request returns the instruments that are supported for trading on Paradigm. They follow the same naming conventions as the exchange they can be traded upon.

If the resulting returned list of instruments is too large, it is divided into pages. Each request returns a single page.

Parameters

Name	In	Type	Required	Description
asset	query	string	false	Type of currency. Valid values include "BCH", "BTC" or "ETH".
cursor	query	string	false	The next or previous cursor from the paginated result set.
type	query	string	false	Type of instrument. Valid values include "FUTURE" or "OPTION".
venue	query	string	false	Venue to return instruments for. Value values include "BIT", "CME", or "DBT"

/instruments/ Response example

200 Response

{
   "count":895,
   "next":"c12dEx=",
   "results":[
      {
         "name":"BTC-19JAN21-32000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-19JAN21-32000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-19JAN21-34000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-19JAN21-34000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-19JAN21-35000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-19JAN21-35000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-19JAN21-36000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-19JAN21-36000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-19JAN21-36500-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-19JAN21-36500-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-19JAN21-37000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-19JAN21-37000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-19JAN21-38000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-19JAN21-38000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-19JAN21-40000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-19JAN21-40000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-20JAN21-36000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-20JAN21-36000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-20JAN21-37000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-20JAN21-37000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-20JAN21-38000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-20JAN21-38000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-20JAN21-40000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-20JAN21-40000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-25000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-25000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-25500-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-25500-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-26000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-26000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-26500-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-26500-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-27000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-27000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-27500-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-27500-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-28000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-28000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-28500-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-28500-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-29000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-29000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-29500-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-29500-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-30000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-30000-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-30500-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-30500-C",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-31000-P",
         "type":"OPTION",
         "venue":"DBT"
      },
      {
         "name":"BTC-22JAN21-31000-C",
         "type":"OPTION",
         "venue":"DBT"
      }
   ]
}

Responses

Status	Meaning	Description	Schema
200	OK	none	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
count	number	Y	None	Number of available instruments.
next	string	Y	None	Cursor to use to retrieve the next page of results. Equal to "null" if there are no more pages.
results	array of objects	Y	None	Array of objects of instruments and their details.
> name	string	Y	None	Name of the instrument.
> type	string	Y	None	Type of instrument.
> venue	string	Y	None	Venue the instrument is available upon.

Error Codes

HTTP Status Code	Paradigm Code	Message	Meaning
400	101	Unknown type	An invalid Type key value was provided.
400	102	Unknown venue	An invalid Venue key value was provided.
404		Invalid cursor	An invalid cursor value was provided.

/counterparties/ [GET]

/counterparties/ Request example

# You can also use wget
curl -X GET https://api.chat.paradigm.co/counterparties/ \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer ACCESS_KEY'


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer ACCESS_KEY'
};

fetch('https://api.chat.paradigm.co/counterparties/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

# built ins
import base64
import hmac
import time
from urllib.parse import urljoin
import json

# installed
import requests


access_key = '<access-key>'
secret_key = '<secret-key>'

signing_key = base64.b64decode(secret_key)

print('Paradigm Account Access Key: {}'.format(access_key))
print('Paradigm Account Secret Key: {}'.format(signing_key))

# Request Body

host = 'https://api.test.paradigm.co'

# GET /counterparties/
method = 'GET'
path = '/counterparties/'

body = b''

message = method.encode('utf-8') + b'\n'
message += path.encode('utf-8') + b'\n'

timestamp = str(int(time.time() * 1000))
message = timestamp.encode('utf-8') + b'\n' + message
digest = hmac.digest(signing_key, message, 'sha256')
signature = base64.b64encode(digest)


headers = {
            'Paradigm-API-Timestamp': timestamp,
            'Paradigm-API-Signature': signature,
            'Authorization': f'Bearer {access_key}'
            }

# Send request
response = requests.get(urljoin(host, path),
                        headers=headers)

print(response.status_code)
print(response.text)

package main

import (
       "bytes"
       "net/https"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer ACCESS_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := https.NewRequest("GET", "http://api.chat.paradigm.co/counterparties/", data)
    req.Header = headers

    client := &https.Client{}
    resp, err := client.Do(req)
    // ...
}

A GET /counterparties/ request returns the counterparties that the user is permissioned to trade with on Paradigm.

If the resulting returned list of counterparties is too large, it is divided into pages. Each request returns a single page.

Parameters

Name	In	Type	Required	Description
cursor	query	string	false	The next or previous cursor from the paginated result set.
type	query	string	false	Use 'LP' to filter only Liquidity Providers.

/counterparties/ Response example

200 Response

{
   "count":176,
   "next":"c12dEx=",
   "results":[
      {
         "firm_name":"0420",
         "ticker":"APR",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"0420",
         "ticker":"MAY",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"0420",
         "ticker":"MAY01",
         "venues":[
            "CME"
         ]
      },
      {
         "firm_name":"062020",
         "ticker":"JUN11",
         "venues":[
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"062020",
         "ticker":"05J2",
         "venues":[
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"062020",
         "ticker":"05J3",
         "venues":[
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"17bits",
         "ticker":"17B",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"Alpha5",
         "ticker":"ALP5",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"APEX(Stage)",
         "ticker":"SHIVA",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"APEX(Stage)",
         "ticker":"SAMBO",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"APEX(Stage)",
         "ticker":"RUDRA",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"APEX(Stage)",
         "ticker":"HARA",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"APEX(Stage)",
         "ticker":"NATA",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"APEX(Stage)",
         "ticker":"BHOLE",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"APEX(Stage)",
         "ticker":"KEDAR",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"APEX(Stage)",
         "ticker":"BADRI",
         "venues":[
            "BIT"
         ]
      },
      {
         "firm_name":"Bloomberg",
         "ticker":"CRYPT",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Bloomberg",
         "ticker":"GBLOP",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"Champagne Trust",
         "ticker":"DOM",
         "venues":[
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"DARKO",
         "ticker":"DARKO",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"DARKO1",
         "ticker":"DARK1",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"Dragonfly Capital",
         "ticker":"DFLY",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"EP10",
         "ticker":"DSK10",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"EP2",
         "ticker":"DSK2",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"EP3",
         "ticker":"DSK3",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"EP4",
         "ticker":"DSK4",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"EP5",
         "ticker":"DSK5",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"EP6",
         "ticker":"DSK6",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"EP7",
         "ticker":"DSK7",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"EP8",
         "ticker":"DSK8",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"EP9",
         "ticker":"DSK9",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"EP99",
         "ticker":"DSK99",
         "venues":[
            "BIT",
            "CME",
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK4",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK5",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK6",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK7",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK8",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK9",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK10",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK11",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK12",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK13",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK14",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK18",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK19",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK20",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK21",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK22",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK23",
         "venues":[
            "DBT"
         ]
      },
      {
         "firm_name":"Epam_Maker",
         "ticker":"MAK24",
         "venues":[
            "DBT"
         ]
      }
   ]
}

Responses

Status	Meaning	Description	Schema
200	OK	none	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
count	number	Y	None	Number of available counterparties.
next	string	Y	None	Cursor to use to retrieve the next page of results. Equal to "null" if there are no more pages.
results	array of objects	Y	None	Array of objects of counterparties.
> firm_name	string	Y	None	Name of counterparty on Paradigm.
> ticker	string	Y	None	Desk Name on Paradigm.
> venues	[string]	Y	None	List of strings of venue counterparty is available upon.

Error Codes

HTTP Status Code	Paradigm Code	Message	Meaning
404		Invalid cursor	An invalid cursor value was provided.

/rfq/create/ [POST]

/rfq/create/ Request example

# You can also use wget
curl -X POST https://api.chat.paradigm.co/rfq/create/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer ACCESS_KEY'

const inputBody = '{
  "account": {
    "name": "string",
    "clearing_account_name": "string",
    "trader_id": "string"
  },
  "client_order_id": "string",
  "anonymous": true,
  "counterparties": [
    "strin"
  ],
  "expires_in": 1800,
  "legs": [
    {
      "price": "string",
      "quantity": "string",
      "side": "BUY",
      "instrument": "string",
      "venue": "BIT"
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer ACCESS_KEY'
};

fetch('https://api.chat.paradigm.co/rfq/create/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

# built ins
import base64
import hmac
import time
from urllib.parse import urljoin
import json
from random import randint

# installed
import requests

access_key = '<access-key>'
secret_key = '<secret-key>'

signing_key = base64.b64decode(secret_key)

print('Paradigm Account Access Key: {}'.format(access_key))
print('Paradigm Account Secret Key: {}'.format(signing_key))

# Request Body

host = 'https://api.test.paradigm.co'

# POST /rfq/create/
method = 'POST'
path = '/rfq/create/'

body = b''

client_order_id_random = randint(1, 1000000000)
# print('Client_Order_Id: {}'.format(client_order_id_random))

payload = {
            "account": {
                        "name": "ParadigmTestTwo"
                        },
            "client_order_id": client_order_id_random,
            "anonymous": "false",
            "counterparties": [
                                "DSK4", "DSK5"
                                ],
            "expires_in": 120,
            "legs": [
                    {
                    "quantity": "25",
                    "side": "BUY",
                    "instrument": "BTC-31DEC21-36000-C",
                    "venue": "DBT"
                    }
                    ]
            }

json_payload = json.dumps(payload).encode('utf-8')

message = method.encode('utf-8') + b'\n'
message += path.encode('utf-8') + b'\n'
message += json_payload

timestamp = str(int(time.time() * 1000))
message = timestamp.encode('utf-8') + b'\n' + message
digest = hmac.digest(signing_key, message, 'sha256')
signature = base64.b64encode(digest)


headers = {
            'Paradigm-API-Timestamp': timestamp,
            'Paradigm-API-Signature': signature,
            'Authorization': f'Bearer {access_key}'
            }

# Send request
response = requests.post(urljoin(host, path),
                         headers=headers,
                         json=payload)

print(response.status_code)
print(response.text)

package main

import (
       "bytes"
       "net/https"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer ACCESS_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := https.NewRequest("POST", "http://api.chat.paradigm.co/rfq/create/", data)
    req.Header = headers

    client := &https.Client{}
    resp, err := client.Do(req)
    // ...
}

A POST /rfq/create/ request creates an RFQ.

An /rfq/create/ request has the following workflow:

The Taker sends an /rfq/create/ request to Paradigm.
Paradigm sends an /rfq/create/ response to the Taker.
1. If the /rfq/create/ request is valid, the RFQ object is returned to the Taker.
2. If the /rfq/create/ request is invalid, an Error object is returned to the Taker.
If the /rfq/create/ request is valid, Paradigm sends a Notification on the rfq notification channel to the Taker & the counterparties listed in the RFQ specifying the details of the new RFQ.

Note: You are able to find the instrument names from the GET /instruments/ request or the name returned from the exchanges. You are able to pull counterparties desk tickers from GET /counterparties/. Takers are only able to RFQ up to 60 counterparties at the present moment.

The Auto-Market Makers on the Test Environment have the desk names are "DSK2", "DSK3", "DSK4", "DSK5", and "MT2".

/rfq/create/ Body parameter example

{
  "account": {
              "name": "ParadigmTestTwo"
              },
  "client_order_id": 123,
  "anonymous": "false",
  "counterparties": [
                      "DSK4", "DSK5"
                      ],
  "expires_in": 120,
  "legs": [
          {
          "quantity": "25",
          "side": "BUY",
          "instrument": "BTC-31DEC21-36000-C",
          "venue": "DBT"
          }
          ]
  }

Parameters

Name	In	Type	Required	Description
account	body	object	Y	Object of Paradigm Account information
> name	body	string	Y	Paradigm API Key name.
> clearing_account_name	body	string	N	Required value if using "CME" as a venue.
> trader_id	body	string	N	Required value if using "CME" as a venue.
client_order_id	body	string	Y	Unique identifier created by the user.
anonymous	body	boolean	N	Submit RFQ on a disclosed or anonymous basis.
counterparties	body	[string]	Y	List of strings of the Desk Names of the other counterparties to the RFQ.
expires_in	body	integer	N	Length in seconds the RFQ is available for. Valid values are between 60-120.
legs	body	array of objects	Y	An array of objects containing each leg of the RFQ.
> price	body	decimal	N	Requested price of leg for hedge RFQs.
> quantity	body	decimal	Y	Number of contracts of the leg.
> side	body	string	Y	Direction of the RFQ leg. Valid values include "BUY" and "SELL".
> instrument	body	string	Y	Instrument name, for example: "BTC-PERPETUAL".
> venue	body	string	Y	Exchange to send the RFQ. Valid values include "DBT", "BIT", and "CME".

/rfq/create/ Response example

201 Response

{
   "created":1611033737572.134,
   "desk":"DSK2",
   "rfq_id":22534,
   "account":{
      "name":"ParadigmTestTwo"
   },
   "client_order_id":"769195219",
   "legs":[
      {
         "instrument":"BTC-31DEC21-36000-C",
         "quantity":25.0,
         "side":"BUY",
         "venue":"DBT"
      }
   ],
   "status":"ACTIVE",
   "valid_until":1611033857557.6538,
   "stream":false,
   "counterparties":[
      "DSK4",
      "DSK5"
   ]
}

Responses

Status	Meaning	Description	Schema
201	Created	none	Inline

Response Schema

Status Code 201

Name	Type	Required	Restrictions	Description
created	decimal	Y	None	The time the RFQ was created in the number of milliseconds since epoch (January 1, 1970).
desk	string	Y	None	The desk name which created the RFQ.
rfq_id	number	Y	None	The unique identifier of the RFQ. This value is determined by Paradigm.
account	object	Y	None	An object of the account information relating to the creation of the RFQ.
> name	string	Y	None	The Paradigm API Key name.
> clearing_account_name	string	N	None	Only present if using "CME" as the venue.
> trader_id	string	N	None	Only present if using "CME" as the venue.
client_order_id	string	Y	none	Unique identifier created by user.
legs	array of objects	Y	None	Array of objects of the legs apart of the RFQ.
> instrument	string	Y	None	The leg's instrument name.
> price	decimal	N	none	Price of leg if a hedge has been added.
> quantity	decimal	Y	None	The number of contracts of the leg.
> side	string	Y	None	The Direction of leg. Valid values include "BUY" and "SELL".
> venue	string	Y	None	The Exchange the RFQ was created upon.
status	string	Y	None	The Status of the RFQ. Valid values include "ACTIVE", "CANCELED", "FILLED"
valid_until	decimal	Y	None	The time the RFQ will expire in the number of milliseconds since epoch (January 1, 1970).
stream	boolean	Y	None	Indicates if the RFQ is an RFS stream or not.
counterparties	[string]	Y	None	List of strings of the other Counterparties apart of the RFQ.

Error Codes

HTTP Status Code	Paradigm Code	Message	Meaning
400		'Anonymous' key Must be a valid boolean.	Anonymous key must be a valid boolean.
400		Future leg price is outside exchange price bands.	The hedge leg's price is outside the exchange's accepted price bands.
400	1301	Duplicate client_order_id	Non-Unique client_order_id value provided.
400	1302	Invalid account information	Invalid account information provided.
400	1303	No counterparties specified	No counterparties specified in request.
400	1304	Invalid counterparty	Invalid or duplicate counterparty(ies) requested.
400	1305	Invalid expires_in	Invalid expires_in value provided. Too small (<60) or too large.
400	1306	Invalid instrument	Invalid instrument provided as apart of request.
400	1308	Invalid Price	Invalid price provided as apart of request.
400	1309	Negative quantity	Negative quantity value was provided as apart of request.
400	13010	Invalid quantity	Invalid quantity specified in leg array.
400	1311	Unknown Venue	Invalid venue provided as apart of request.
400	1312	Invalid price for instrument	You are unable to request a price for single-leg instrument RFQ.
400	1313	Quantity below minimum block size	Request RFQ below Exchange's set minimum block size.
400	1314	Maximum 60 counterparties allowed	More than 60 counterparties requested to be apart of the RFQ.

/rfq/cancel/ [POST]

/rfq/cancel/ Request example

# You can also use wget
curl -X POST https://api.chat.paradigm.co/rfq/cancel/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer ACCESS_KEY'

const inputBody = '{
  "rfq_id": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer ACCESS_KEY'
};

fetch('https://api.chat.paradigm.co/rfq/cancel/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

# built ins
import base64
import hmac
import time
from urllib.parse import urljoin
import json
from random import randint

# installed
import requests

access_key = '<access-key>'
secret_key = '<secret-key>'

signing_key = base64.b64decode(secret_key)

print('Paradigm Account Access Key: {}'.format(access_key))
print('Paradigm Account Secret Key: {}'.format(signing_key))

# Request Body

host = 'https://api.test.paradigm.co'

# POST /rfq/cancel/
method = 'POST'
path = '/rfq/cancel/'

body = b''

client_order_id_random = randint(1, 1000000000)
# print('Client_Order_Id: {}'.format(client_order_id_random))

payload = {
            "rfq_id": 22535
            }

json_payload = json.dumps(payload).encode('utf-8')

message = method.encode('utf-8') + b'\n'
message += path.encode('utf-8') + b'\n'
message += json_payload

timestamp = str(int(time.time() * 1000))
message = timestamp.encode('utf-8') + b'\n' + message
digest = hmac.digest(signing_key, message, 'sha256')
signature = base64.b64encode(digest)


headers = {
            'Paradigm-API-Timestamp': timestamp,
            'Paradigm-API-Signature': signature,
            'Authorization': f'Bearer {access_key}'
            }

# Send request
response = requests.post(urljoin(host, path),
                         headers=headers,
                         json=payload)

print(response.status_code)
print(response.text)

package main

import (
       "bytes"
       "net/https"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer ACCESS_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := https.NewRequest("POST", "http://api.chat.paradigm.co/rfq/cancel/", data)
    req.Header = headers

    client := &https.Client{}
    resp, err := client.Do(req)
    // ...
}

A POST /rfq/cancel/ request cancels an exisitng RFQ you created.

An /rfq/cancel/ request has the following workflow:

The creator of an RFQ sends a /rfq/cancel/ request to Paradigm.
Paradigm sends an /rfq/cancel/ response to the creator.
1. If the /rfq/cancel/ request is valid, the RFQ object is returned to the creator.
2. If the /rfq/cancel/ request is invalid, an Error object is returned to the creator.
If the /rfq/cancel/ request is valid, Paradigm sends a Notification on the quote notification channel to the counterparties with active Quotes specifying that the Quotes are now canceled.
If the /rfq/cancel/ request is valid, Paradigm sends a Notification on the rfq notification channel to the counterparties aparty to the RFQ and other members of the user's desk specifying that the RFQ is now canceled.

/rfq/cancel/ Body parameter example

{
  "rfq_id": 22535
}

Parameters

Name	In	Type	Required	Description
body	body	object	Y	none
rfq_id	body	number	Y	The rfq_id value created by Paradigm.

/rfq/cancel/ Response example

200 Response

{
   "created":1611034695052.4731,
   "desk":"DSK2",
   "rfq_id":22535,
   "account":{
      "name":"ParadigmTestTwo"
   },
   "client_order_id":"641457979",
   "legs":[
      {
         "instrument":"BTC-31DEC21-36000-C",
         "quantity":25.0,
         "side":"BUY",
         "venue":"DBT"
      }
   ],
   "status":"CANCELED",
   "stream":false,
   "counterparties":[
      "DSK4",
      "DSK5"
   ],
   "updated":1611034702624.0151
}

Responses

Status	Meaning	Description	Schema
200	OK	none	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
created	decimal	Y	None	The time the RFQ was created in the number of milliseconds since epoch (January 1, 1970).
desk	string	Y	None	The Paradigm Desk Name of the creator of the RFQ.
rfq_id	number	Y	None	The RFQ unique identifier. This value is created by Paradigm.
account	array	Y	None	An array of attributes related to the account which created the RFQ.
> name	string	Y	None	The creator's Paradigm API Key name.
> clearing_account_name	string	N	None	Only present if using "CME" as a venue.
> trader_id	string	N	Nnone	Only present if using "CME" as a venue.
client_order_id	string	Y	None	Unique identifier created by user.
legs	array of objects	Y	None	Array of objects containing the leg information of the RFQ.
> instrument	string	Y	None	The leg's instrument name.
> price	decimal	N	None	Price of leg if a hedge has been added.
> quantity	decimal	Y	None	The number of contracts of the leg.
> side	string	Y	None	The Direction of leg. Valid values include "BUY" and "SELL".
> venue	string	Y	None	The Exchange the RFQ would have been executed on.
status	string	Y	None	The status of the RFQ. Valid values include "ACTIVE", "CANCELED", and "FILLED".
stream	boolean	Y	None	Indicates if the RFQ is an RFS.
counterparties	[string]	Y	None	List of strings of the other counterparties involved in the RFQ.
updated	decimal	Y	None	The time the RFQ was last updated in the number of milliseconds since epoch (January 1, 1970).

Error Codes

HTTP Status Code	Paradigm Code	Message	Meaning
400	1401	Unknown rfq_id	Invalid rfq_id provided as apart of request.
400	1402	Too late to cancel.	RFQ has already expired or been filled.

rfq [GET]

/rfq/ Request example

# You can also use wget
curl -X GET https://api.chat.paradigm.co/rfq/ \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer ACCESS_KEY'


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer ACCESS_KEY'
};

fetch('https://api.chat.paradigm.co/rfq/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

# built ins
import base64
import hmac
import time
from urllib.parse import urljoin
import json

# installed
import requests


access_key = '<access-key>'
secret_key = '<secret-key>'

signing_key = base64.b64decode(secret_key)

print('Paradigm Account Access Key: {}'.format(access_key))
print('Paradigm Account Secret Key: {}'.format(signing_key))

# Request Body

host = 'https://api.test.paradigm.co'

# GET /rfq/
method = 'GET'
path = '/rfq/?venue=DBT&asset=BTC'

body = b''

message = method.encode('utf-8') + b'\n'
message += path.encode('utf-8') + b'\n'

timestamp = str(int(time.time() * 1000))
message = timestamp.encode('utf-8') + b'\n' + message
digest = hmac.digest(signing_key, message, 'sha256')
signature = base64.b64encode(digest)


headers = {
            'Paradigm-API-Timestamp': timestamp,
            'Paradigm-API-Signature': signature,
            'Authorization': f'Bearer {access_key}'
            }

# Send request
response = requests.get(urljoin(host, path),
                        headers=headers)

print(response.status_code)
print(response.text)

package main

import (
       "bytes"
       "net/https"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer ACCESS_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := https.NewRequest("GET", "http://api.chat.paradigm.co/rfq/", data)
    req.Header = headers

    client := &https.Client{}
    resp, err := client.Do(req)
    // ...
}

A GET /rfq/ request returns the current state of RFQs that the user is a counterparty to (either as the creator or the receiver).

If the resulting returned list of RFQs is too large, it is divided into pages. Each request can return a single page.

Parameters

Name	In	Type	Required	Description
client_order_id	query	string	N	The client's unique identifier for the RFQ.
cursor	query	string	N	The next or previous cursor from the paginated result set.
rfq_id	query	string	N	Paradigm's unique identifier for the RFQ.
status	query	string	N	The status of the RFQ. Values can include "ACTIVE", "CANCELED", and "FILLED".

/rfq/ Example response

200 Response

{
   "count":2441,
   "next":"c12dEx=",
   "results":[
      {
         "account":{
            "name":"ParadigmTestOne"
         },
         "client_order_id":"",
         "counterparties":[
            "MSTL1",
            "DSK2",
            "DSK3",
            "DSK4",
            "DSK5"
         ],
         "created":1608267227834.84,
         "desk":"DSK1",
         "fills":[

         ],
         "legs":[
            {
               "instrument":"BTC-18DEC20-13250-C",
               "quantity":25.0,
               "side":"SELL",
               "venue":"DBT"
            },
            {
               "instrument":"BTC-19DEC20-21125-C",
               "quantity":25.0,
               "side":"BUY",
               "venue":"DBT"
            }
         ],
         "maker":true,
         "quotes":[
            {
               "desk":"DSK5",
               "valid_until":null,
               "created":1608267227854.909,
               "legs":[
                  {
                     "price":null,
                     "quantity":25.0,
                     "instrument":"BTC-18DEC20-13250-C",
                     "side":"SELL",
                     "venue":"DBT"
                  },
                  {
                     "price":null,
                     "quantity":25.0,
                     "instrument":"BTC-19DEC20-21125-C",
                     "side":"BUY",
                     "venue":"DBT"
                  }
               ],
               "quote_id":25092,
               "rfq_id":18753,
               "side":"SELL",
               "status":"CANCELED"
            },
            {
               "desk":"DSK4",
               "valid_until":null,
               "created":1608267227869.377,
               "legs":[
                  {
                     "price":null,
                     "quantity":25.0,
                     "instrument":"BTC-18DEC20-13250-C",
                     "side":"SELL",
                     "venue":"DBT"
                  },
                  {
                     "price":null,
                     "quantity":25.0,
                     "instrument":"BTC-19DEC20-21125-C",
                     "side":"BUY",
                     "venue":"DBT"
                  }
               ],
               "quote_id":25093,
               "rfq_id":18753,
               "side":"SELL",
               "status":"CANCELED"
            }
         ]
      }

Responses

Status	Meaning	Description	Schema
200	OK	none	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
count	number	Y	None	Number of available RFQs.
next	string	Y	None	Cursor to use to retrieve the next page of results. Equal to "null" if there are no more pages.
results	array of objects	Y	None	An array of objects of RFQs.
> account	array	Y	None	Array of information about the creator of the RFQ.
>> name	string	N	None	The Paradigm API Key name aparty to the RFQ.
>> clearing_account_name	string	N	None	"CME" venue clearing account name.
>> trader_id	string	N	None	"CME" venue trader_id value.
> client_order_id	string	Y	None	Client created unique identifier.
> counterparties	[string]	Y	None	Counterparties involved with the RFQ. This value for RFS is always empty.
> created	decimal	Y	None	The time the RFQ was created in the number of milliseconds since epoch (January 1, 1970).
> desk	string	N	None	Paradigm Desk name of the RFQ creator.
> fills	array of objects	N	None	Array of objects of the fills.
> legs	array of objects	Y	None	Array of objects containing the legs of the RFQ.
>> instrument	string	Y	None	The leg's instrument name.
>> quantity	decimal	Y	None	The size in contracts of the leg. This key is not present for RFS RFQs.
>> side	string	Y	None	The Direction of the leg. Valid values include "BUY" and "SELL".
>> venue	string	Y	None	Venue of RFQ.
> maker	boolean	N	None	Identifies if requesting party is a maker.
> quotes	array of objects	N	None	Array of objects containing the quotes provided for the RFQ.
>> desk	string	N	None	Paradigm Desk name of the Quote creator.
>> valid_until	decimal	Y	None	The time until the Quote expires in the number of milliseconds since epoch (January 1, 1970).
>> created	decimal	Y	None	The time the Quote was created in the number of milliseconds since epoch (January 1, 1970).
>> legs	array of objects	Y	None	An array of objects containing the Quotes of the individual legs.
>>> instrument	string	Y	None	The leg's instrument name.
>>> price	decimal	N	None	The price of the leg.
>>> quantity	decimal	N	None	The size in contracts of the leg.
>>> side	string	Y	None	The direction of the leg. Valid values include "BUY" and "SELL".
>>> venue	string	Y	None	The venue the RFQ would be executed on. Valid values include "DBT", "CME", and "BIT".
>> quote_id	integer	Y	None	The unique identifier of the quote. Paradigm determines this value.
>> rfq_id	integer	Y	None	Unqiue of the RFQ determined by Paradigm.
>> side	string	Y	None	Side being quoted. Valid values include "BUY" and "SELL".
>> status	string	Y	None	The status of the Quote. Valid values include "ACTIVE", "EXPIRED".

Error Codes

HTTP Status Code	Paradigm Code	Message	Meaning
400	2103	Unavailable RFQ.	Unavailable RFQ.
404		Invalid cursor.	Invalid cursor value requested.

/quote/create/ [POST]

/quote/create/ Request examples

# You can also use wget
curl -X POST https://api.chat.paradigm.co/quote/create/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer ACCESS_KEY'

const inputBody = '{
  "account": {
    "name": "string",
    "clearing_account_name": "string",
    "trader_id": "string"
  },
  "client_order_id": "string",
  "expires_in": 10,
  "legs": [
    {
      "side": "BUY",
      "instrument": "string",
      "venue": "BIT",
      "price": "string",
      "quantity": "string"
    }
  ],
  "rfq_id": 0,
  "side":"SELL"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer ACCESS_KEY'
};

fetch('https://api.chat.paradigm.co/quote/create/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

# built ins
import base64
import hmac
import time
from urllib.parse import urljoin
import json
from random import randint

# installed
import requests

access_key = '<access-key>'
secret_key = '<secret-key>'

signing_key = base64.b64decode(secret_key)

print('Paradigm Account Access Key: {}'.format(access_key))
print('Paradigm Account Secret Key: {}'.format(signing_key))

# Request Body

host = 'https://api.test.paradigm.co'

# POST /quote/create/
method = 'POST'
path = '/quote/create/'

body = b''

client_order_id_random = randint(1, 1000000000)
# print('Client_Order_Id: {}'.format(client_order_id_random))

payload = {
            "account": {
                "name": "ParadigmTestOne"
            },
            "client_order_id": client_order_id_random,
            "expires_in": 60,
            "legs": [
                {
                    "price": 39450,
                    "quantity": 20000,
                    "instrument": "BTC-PERPETUAL",
                    "side": "BUY",
                    "venue": "DBT"
                },
                {
                    "price": 47000,
                    "quantity": 20000,
                    "instrument": "BTC-25JUN21",
                    "side": "SELL",
                    "venue": "DBT"
                }
            ],
            "rfq_id": 22539,
            "side":"SELL"
        }

json_payload = json.dumps(payload).encode('utf-8')

message = method.encode('utf-8') + b'\n'
message += path.encode('utf-8') + b'\n'
message += json_payload

timestamp = str(int(time.time() * 1000))
message = timestamp.encode('utf-8') + b'\n' + message
digest = hmac.digest(signing_key, message, 'sha256')
signature = base64.b64encode(digest)


headers = {
            'Paradigm-API-Timestamp': timestamp,
            'Paradigm-API-Signature': signature,
            'Authorization': f'Bearer {access_key}'
            }

# Send request
response = requests.post(urljoin(host, path),
                         headers=headers,
                         json=payload)

print(response.status_code)
print(response.text)

package main

import (
       "bytes"
       "net/https"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer ACCESS_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := https.NewRequest("POST", "http://api.chat.paradigm.co/quote/create/", data)
    req.Header = headers

    client := &https.Client{}
    resp, err := client.Do(req)
    // ...
}

A /quote/create/ request allows you to Quote an RFQ you are a counterparty to.

A Quote represents a single side of the trade, either the "BUY" or "SELL", specified by the top-level "side" field.

To quote both sides of an RFQ, two quotes would need to be created, each with it's own unique "client_order_id".

A /quote/create/ request has the following workflow:

The receiver of an RFQ sends a /quote/create/ request to Paradigm.
Paradigm sends a /quote/create/ response to the RFQ receiver.
1. If the /quote/create/ request is valid, the Quote object is returned to the RFQ receiver.
2. If the /quote/create/ request is invalid, an Error object is returned to the RFQ receiver.
If the /quote/create/ request is valid, Paradigm sends a Notification on the quote JSON-RPCoverWebSockets Notification channel to the creator of the RFQ and other members of the user's desk specifying a new response to the RFQ.

Important Note: You must quote the entire RFQ and not part of the legs or only part of the quantity.

/quote/create/ Body parameter example

  {
    "account": {
        "name": "ParadigmTestOne"
    },
    "client_order_id": "123",
    "expires_in": "60",
    "legs": [
        {
          "price": 39450,
          "quantity": 20000,
          "instrument": "BTC-PERPETUAL",
          "side": "BUY",
          "venue": "DBT"
        }
    ],
    "rfq_id": 22539,
    "side": "SELL"
  }

Parameters

Name	In	Type	Required	Description
account	body	object	Y	Paradigm Account information of Quote creator.
> name	body	string	Y	The Name of Paradigm API Key.
> clearing_account_name	body	string	N	Required if venue is "CME".
> trader_id	body	string	N	Required if venue is "CME".
client_order_id	body	string	Y	Client determined unique identifier.
expires_in	body	integer	Y	Number of seconds quote is available for. Valid values between 10-120.
legs	body	array of objects	Y	An array of objects of each leg of the RFQ.
> price	body	decimal	Y	The price of the leg. Note, DBT BTC Options can only be to 4 decimal places. DBT FUT to 2 decimals.
> quantity	body	decimal	Y	The size of the leg in contracts.
> instrument	body	string	Y	The leg's instrument name.
> side	body	string	Y	Direction of the leg. Valid values include "BUY" and "SELL".
> venue	body	string	Y	Venue of the RFQ. Valid values include "DBT", "BIT", "CME".
rfq_id	body	integer	Y	Unqiue identifier of RFQ. Paradigm determines this value.
side	body	string	Y	Side being quoted. Valid values include "BUY" and "SELL".

/quote/create/ Example response

201 Response

{
   "desk":"DSK1",
   "valid_until":1611038442838.6272,
   "account":{
      "name":"ParadigmTestOne"
   },
   "client_order_id":"49826055",
   "created":1611038342698.2578,
   "legs":[
      {
         "price":39450.0,
         "quantity":20000.0,
         "instrument":"BTC-PERPETUAL",
         "side":"BUY",
         "venue":"DBT"
      }
   ],
   "quote_id":84069,
   "rfq_id":22537,
   "side": "SELL",
   "status":"ACTIVE"
}

Responses

Status	Meaning	Description	Schema
201	Created	none	Inline

Response Schema

Status Code 201

Name	Type	Required	Restrictions	Description
desk	string	Y	None	The Paradigm Desk name of the Quote creator.
valid_until	decimal	Y	None	The time the Quote is valid until in the number of milliseconds since epoch (January 1, 1970).
account	object	Y	None	An object of account information about the creator of the Quote.
> name	string	Y	None	The Name of the Paradigm API Key.
> clearing_account_name	string	N	None	Account identifier if venue is "CME".
> trader_id	string	N	None	Account identifier if venue is "CME".
client_order_id	string	Y	None	Client determined unique identifier.
created	decimal	Y	None	The time the Quote was created in the number of milliseconds since epoch (January 1, 1970).
expires_in	integer	N	None	Maximum number of seconds the Quote is available for.
legs	array of objects	Y	None	An array of objects of the legs of the Quote.
> instrument	string	Y	None	The leg's instrument name.
> price	decimal	N	None	The price of the leg.
> quantity	decimal	N	None	The number of contracts of the leg.
> side	string	Y	None	Direction of the quoted leg.
> venue	string	Y	None	Venue of the RFQ.
rfq_id	integer	Y	None	Unqiue identifier of the RFQ. Paradigm determines this value.
quote_id	integer	Y	None	Unique identifier of the Quote. Paradigm determines this value.
side	string	Y	None	Side being quoted. Valid values include "BUY" and "SELL".

Error Codes

HTTP Status Code	Paradigm Code	Message	Meaning
400	1	Invalid desk product configuration	Likely expires_in band outside of values set in your admin dashboard or missing key from payload in request. Leg Prices can also not be negative. Bid can also not be greater than offer.
400	1302	Invalid account information	Invalid account information provided in request.
400	2101	Duplicate client_order_id	Duplicate client_order_id provided in request.
400	2102	Unknown rfq_id	Incorrect or missing rfq_id key from request.
400	2103	Unavailable RFQ	RFQ is unavailable to be quoted upon. The RFQ is likely expired, filled or traded away.
400	2104	Invalid leg parameters	Invalid payload provided in request. Likely wrong key value.
400	2105	Cannot change fixed leg price	Hedge leg price must be the same as in the RFQ.
400	2106	Must specify bid or offer	Provide a price in request.
400	2107	Invalid quote parameters	Invalid /quote/create request.
400	2109	This RFQ already has an active quote for that side. Please cancel it before requoting.	There is an ACTIVE existing quote for this side of the RFQ.

/quote/cancel/ [POST]

/quote/cancel/ Request example

# You can also use wget
curl -X POST https://api.chat.paradigm.co/quote/cancel/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer ACCESS_KEY'

const inputBody = '{
  "quote_id": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer ACCESS_KEY'
};

fetch('https://api.chat.paradigm.co/quote/cancel/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

# built ins
import base64
import hmac
import time
from urllib.parse import urljoin
import json

# installed
import requests

access_key = '<access-key>'
secret_key = '<secret-key>'

signing_key = base64.b64decode(secret_key)

print('Paradigm Account Access Key: {}'.format(access_key))
print('Paradigm Account Secret Key: {}'.format(signing_key))

# Request Body

host = 'https://api.test.paradigm.co'

# POST /quote/cancel/
method = 'POST'
path = '/quote/cancel/'

body = b''

payload = {
            "quote_id": 84063
          }

json_payload = json.dumps(payload).encode('utf-8')

message = method.encode('utf-8') + b'\n'
message += path.encode('utf-8') + b'\n'
message += json_payload

timestamp = str(int(time.time() * 1000))
message = timestamp.encode('utf-8') + b'\n' + message
digest = hmac.digest(signing_key, message, 'sha256')
signature = base64.b64encode(digest)


headers = {
            'Paradigm-API-Timestamp': timestamp,
            'Paradigm-API-Signature': signature,
            'Authorization': f'Bearer {access_key}'
            }

# Send request
response = requests.post(urljoin(host, path),
                         headers=headers,
                         json=payload)

print(response.status_code)
print(response.text)

package main

import (
       "bytes"
       "net/https"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer ACCESS_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := https.NewRequest("POST", "http://api.chat.paradigm.co/quote/cancel/", data)
    req.Header = headers

    client := &https.Client{}
    resp, err := client.Do(req)
    // ...
}

A POST /quote/cancel/ request cancels an existing Quote you have created for an ACTIVE RFQ.

A /quote/cancel/ request has the following workflow:

The creator of the quote sends a /quote/cancel/ request to Paradigm.
Paradigm sends a /quote/cancel/ response to the creator.
1. If the /quote/cancel/ request is valid, the Quote object is returned to the creator.
2. If the /quote/cancel/ request is invalid, an Error object is returned to the creator.
If the /quote/cancel/ request is valid, Paradigm sends a Notification on the quote JSON-RPCoverWebSockets Notifications channel to the creator of the RFQ and other members of the creator's desk specifying the quote is no longer available.

/quote/cancel/ Body parameter

{
  "quote_id": 2156
}

Parameters

Name	In	Type	Required	Description
body	body	object	true	none
quote_id	body	integer	Y	none

/quote/cancel/ Response Example

200 Response

{
   "desk":"DSK1",
   "valid_until":null,
   "account":{
      "name":"ParadigmTestOne"
   },
   "client_order_id":"613310893",
   "created":1611038225971.4749,
   "legs":[
      {
         "instrument":"BTC-PERPETUAL",
         "price":null,
         "quantity":20000.0,
         "side":"BUY",
         "venue":"DBT"
      }
   ],
   "quote_id":84063,
   "rfq_id":22537,
   "side": "SELL",
   "status":"CANCELED",
   "updated":1611038331810.966
}

Responses

Status	Meaning	Description	Schema
200	OK	none	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
desk	string	Y	None	The desk name of the Quote creator.
valid_until	decimal or null	Y	None	null if the quote has been successfully canceled.
account	object	Y	None	An object of the Quote creator's account information.
> name	string	Y	None	The Paradigm API Key name.
> clearing_account_name	string	N	None	Account information if venue is "CME".
> trader_id	string	N	None	Account information if venue is "CME".
client_order_id	string	Y	None	User determined unique identifier.
created	decimal	Y	None	The time the Quote was created in the number of milliseconds since epoch (January 1, 1970).
legs	array of objects	Y	None	An array of objects of the legs of the Quote.
> instrument	string	Y	None	The leg's instrument name.
> price	decimal	N	None	The price of the leg.
> quantity	decimal	N	None	The contract size of the leg.
> side	string	Y	None	The Direction of the leg.
> venue	string	Y	None	The Venue of the RFQ.
quote_id	integer	Y	None	Unique identifier of the Quote. Paradigm determines this value.
rfq_id	integer	Y	None	Unique identifier of RFQ. Paradigm determines this value.
side	string	Y	None	Side being quoted. Valid values include "BUY" and "SELL".
status	string	Y	None	Status of the Quote.
updated	decimal	Y	None	The time the Quote is was last updated in the number of milliseconds since epoch (January 1, 1970).

Error Codes

HTTP Status Code	Paradigm Code	Message	Meaning
400	2201	Unknown quote_id	Unknown quote_id.
400	2202	Too late to cancel	Quote is expired, filled, or does not exist.

/quote/execute/ [POST]

/quote/execute/ Request example

# You can also use wget
curl -X POST https://api.chat.paradigm.co/quote/execute/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer ACCESS_KEY'

const inputBody = '{
  "rfq_id": 0,
  "legs": [
    {
      "price": "string",
      "quantity": "string",
    }
  ],
  "quote_id": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer ACCESS_KEY'
};

fetch('https://api.chat.paradigm.co/quote/execute/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

# built ins
import base64
import hmac
import time
from urllib.parse import urljoin
import json
from random import randint

# installed
import requests

access_key = '<access-key>'
secret_key = '<secret-key>'

signing_key = base64.b64decode(secret_key)

print('Paradigm Account Access Key: {}'.format(access_key))
print('Paradigm Account Secret Key: {}'.format(signing_key))

# Request Body

host = 'https://api.test.paradigm.co'

# POST /quote/execute/
method = 'POST'
path = '/quote/execute/'

body = b''

payload = {
            "rfq_id": 22540,
            "legs": [
                {
                "price": "38226.8",
                "quantity": "20000",
                }
            ],
            "quote_id": 84073
            }

json_payload = json.dumps(payload).encode('utf-8')

message = method.encode('utf-8') + b'\n'
message += path.encode('utf-8') + b'\n'
message += json_payload

timestamp = str(int(time.time() * 1000))
message = timestamp.encode('utf-8') + b'\n' + message
digest = hmac.digest(signing_key, message, 'sha256')
signature = base64.b64encode(digest)


headers = {
            'Paradigm-API-Timestamp': timestamp,
            'Paradigm-API-Signature': signature,
            'Authorization': f'Bearer {access_key}'
            }

# Send request
response = requests.post(urljoin(host, path),
                         headers=headers,
                         json=payload)

print(response.status_code)
print(response.text)

package main

import (
       "bytes"
       "net/https"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer ACCESS_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := https.NewRequest("POST", "http://api.chat.paradigm.co/quote/execute/", data)
    req.Header = headers

    client := &https.Client{}
    resp, err := client.Do(req)
    // ...
}

A POST /quote/execute/ request executes a Quote. It is only used by the creator of the RFQ, the Taker.

A /quote/execute/ request has the following workflow:

The creator of the RFQ sends a /quote/execute/ request to Paradigm.
Paradigm sends a /quote/execute/ response to the creator.
1. If the /quote/execute/ request is valid, the RFQ object is returned to the creator.
2. If the /quote/execute/ response is invalid, an Error object is returned to the creator. A /quote/execute/ request is invalid if the RFQ or Quote has already expired or been canceled.
If the /quote/execute/ request is valid, Paradigm sends a Notification on the quote JSON-RPCoverWebSocket Notification channel to the creator of the RFQ and the creator of the Quote specifying that a fill is pending.
1. If the exchange confirms the trade, another Notification on the quote channel is sent to all parties listed above that the Trade has been completed and the Quote is filled.
2. If the exchange rejects the trade, another Notification on the quote channel is sent to all parties listed above that the Trade could not be executed and the Quote is rejected. A Trade is all or nothing and a rejection of one leg of the trade will cause the rejection of all legs.
If the Trade has been confirmed, Paradigm sends a Notification on the quote JSON-RPCoverWebSocket Notification channel to other desks that responded to the quote specifying that the quote has been canceled.
If the Trade has been confirmed, Paradigm sends a Notification on the rfq JSON-RPCoverWebSocket Notification channel to all counterparties aparty in the RFQ specifying that the rfq has been filled.

Important Notes:

We will follow the convention from the Maker's (dealer's) perspective with regards to which quote for the Taker to execute.

As the Taker if you wish to "BUY" the RFQ'd structure, you should execute upon the received Quote which has the side key with the property "SELL". Following this, if as the Taker you wish to "SELL" the RFQ'd structure, you should execute upon the received Quote which has the side key with the property "BUY". - Takers are only able to execute upon the best priced quote they receive. After you execute upon a quote, Paradigm checks to ensure the quote is the best available quote. It is critically important you only assume a Trade is completed after you receive confirmation over the trade and trade_confirmation WebSocket Notification channels.

/quote/execute/ Body parameter example

{
  "rfq_id": 22540,
  "legs": [
      {
      "price": "38226.8",
      "quantity": "20000",
      }
  ],
  "quote_id": 84073
}

Parameters

Name	In	Type	Required	Description
rfq_id	body	integer	Y	Unique Identifier of the RFQ. Paradigm determines this value.
legs	body	array of objects	Y	An array of objects of the legs.
> price	body	decimal	Y	The Price of the leg.
> quantity	body	decimal	Y	The Size of the leg.
quote_id	body	integer	Y	Unqiue Identifier of Quote. Paradigm determines this value.

/quote/execute/ Response example

200 Response

{
   "account":{
      "name":"ParadigmTestTwo"
   },
   "client_order_id":"838781960",
   "counterparties":[
      "DSK1",
      "DSK4",
      "DSK5"
   ],
   "created":1611038577702.458,
   "desk":"DSK2",
   "fills":[
      {
         "created":1611038629260.88,
         "legs":[
            {
               "price":38226.8,
               "quantity":20000.0,
               "side":"BUY"
            }
         ],
         "quote_id":84073,
         "rfq_id":22540,
         "desk":"DSK1"
      }
   ],
   "legs":[
      {
         "instrument":"BTC-PERPETUAL",
         "quantity":20000.0,
         "side":"BUY",
         "venue":"DBT"
      }
   ],
   "quotes":[
      {
         "desk":"DSK1",
         "valid_until":1611038679969.7102,
         "created":1611038577707.4758,
         "legs":[
            {
               "instrument":"BTC-PERPETUAL",
               "price":37469.84,
               "quantity":20000.0,
               "side":"BUY",
               "venue":"DBT"
            }
         ],
         "quote_id":84073,
         "rfq_id":22540,
         "side":"SELL",
         "status":"PENDING_FILL"
      }
   ],
   "rfq_id":22540,
   "status":"PENDING_FILL",
   "valid_until":1611038697689.463
}

Responses

Status	Meaning	Description	Schema
201	Created	none	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
account	object	Y	None
> name	string	Y	None	The Name of Paradigm API Key.
> clearing_account_name	string	N	None	Required if venue is "CME".
> trader_id	string	N	None	Required if venue is "CME".
client_order_id	string	Y	None	Client determined unique identifier.
counterparties	[string]	Y	None	List of strings of counterparties involved in the RFQ.
created	decimal	Y	None	The time the RFQ was created in the number of milliseconds since epoch (January 1, 1970).
desk	string	Y	None	The desk name of the creator of the RFQ.
fills	array of objects	Y	None	An array of the fills of the RFQ.
>created	decimal	Y	None	The time the RFQ was created in the number of milliseconds since epoch (January 1, 1970).
>legs	array of objects	Y	None	An array of objects of the RFQ that were filled.
>> price	decimal	Y	None	The price of the filled leg.
>> quantity	decimal	Y	None	The size of the filled leg.
>> side	string	Y	None	The direction of the leg.
>quote_id	integer	Y	None	The unique identifier of the Quote of the Filled leg.
>rfq_id	integer	Y	None	The unique identifier of the RFQ.
>desk	string	Y	None	The desk name of the creator of the RFQ.
legs	array of objects	Y	None	An array of objects the legs of the RFQ.
>instrument	string	Y	None	The leg's instrument name.
>quantity	decimal	Y	None	The size in contracts of the leg.
>side	string	Y	None	The direction of the leg.
>venue	string	Y	None	The venue the RFQ is executed on.
quotes	array of objects	Y	None	An array of the Quotes of the RFQ.
>desk	string	Y	None	The desk name of the creator of the RFQ.
>valid_until	decimal	Y	None	The time the RFQ is valid until in the number of milliseconds since epoch (January 1, 1970).
>created	decimal	Y	None	The time the RFQ was created in the number of milliseconds since epoch (January 1, 1970).
>legs	array of objects	Y	None	An array of objects of the legs of the Quote.
>>instrument	string	Y	None	The leg's instrument name.
>>price	decimal	Y	None	The price of the leg.
>>quantity	decimal	Y	None	The size of the leg.
>>side	string	Y	None	The direction of the leg.
>>venue	string	Y	None	The venue the RFQ is executed on.
>quote_id	integer	Y	None	The unique identifier of the Quote.
>rfq_id	integer	Y	None	The unique identifier of the RFQ.
>status	string	Y	None	The status of the Quote.
rfq_id	integer	Y	None	Unique Identifier of the RFQ.
side	string	Y	None	Side being quoted. Valid values include "BUY" and "SELL".
status	string	Y	None	The status of the RFQ.
valid_until	decimal	Y	None	The time the RFQ is valid until in the number of milliseconds since epoch (January 1, 1970).

Error Codes

HTTP Status Code	Paradigm Code	Message	Meaning
400		RFQ doesn't have a quote for this side of the trade.	Or RFQ has been canceled, expired.
400	2104	Invalid leg parameters	Provided payload is missing or contains incorrect values.
400	2201	Unknown quote_id	Unknown quote_id value.
400	2205	Unable to execute an expired quote	Quote has expired.
400	2302	Invalid leg price	Leg price in payload must match quote provided.

Paradigm API v1

API Connection URLs

Live

Test

Rate Limits

Implementation Paths

High Level

Your solution should:

Your solution should not:

Onboarding

Exchange Testnet URLs

Helpful Reminders

API Workflows

Taker's Perspective

Maker's Perspective

Code Examples

JSON-RPCoverWebSockets

Authentication + Subscribe & Unsubscribe to Notification Channels

RESToverHTTP

All Interactions

Auto-Market Makers

Auto-Takers

Errors

Error Object

Error Codes

Authentication

Error Codes

Generating a Paradigm API Key

Live Environment

Test Environment

Once Created:

Token-based Authentication

HTTP Header

Cookie

Query String Parameter (for JSON-RPCoverWebSocket connections only)

Live URL Example

Test URL Example

Signing Requests

JSON-RPC over WebSocket

JSON-RPC

Error Codes

Cancel on Disconnect

Live Cancel on Disconnect Example

Test Cancel on Disconnect Example

Request Objects

Response Objects

Session Methods

heartbeat

Error Codes

Subscription Methods

subscribe

unsubscribe

Notification Channels

rfq

quote

trade

trade_confirmation

Platform REST Endpoints

/echo/ [POST]

Parameters

Responses

/instruments/ [GET]

Parameters

Responses

Response Schema

Error Codes

/counterparties/ [GET]

Parameters

Responses

Response Schema

Error Codes

/rfq/create/ [POST]

Parameters

Responses

Response Schema

Error Codes

/rfq/cancel/ [POST]

Parameters

Responses

Response Schema