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.

Introduction

Paradigm has three major products, Multi-Dealer RFQ (DRFQ), Global RFQ (GRFQ), and the Future Spread Dashboard (FSPD).

These three products are separate and require separate authenticated interaction via their specific version & product connections URLs.

Paradigm uses RESToverHTTP and JSON-RPCoverWebSockets as our API interfaces to be consistent with the broader crypto space.

Feel free to reach out for any technical support as we would love to help!

DRFQ - Brief Overview

Multi Dealer RFQ (DRFQ) is to be used when you wish to request a quote for a specific size and from a specific group of counterparties. DRFQs are short-lived and designed to be executed within a short time window.

DRFQ will be sunset & deprecated in the future with DRFQv2 taking it's place. Dates will be communicated in advance & DRFQ will be backwards compatible with DRFQv2 for a reasonable period.

To be a party to a DRFQ, you must either be the Initiator (Taker) or a requested counterparty (Maker). DRFQs can be created on a disclosed or anonymous basis, but Makers' desk names are always & only disclosed to the DRFQ Taker.

Makers are unable to see competing Quotes or information relating to the Taker's intended execution side.

If you would like to be recognized as a "Liquidity Provider" or a Maker, please reach out to our Sales team.

Deribit, Bit.com, and the CME are available as venues.

GRFQ - Brief Overview

Global RFQ (GRFQ) is to be used when you wish to contribute to a public auction for a specific RFQ. GRFQ RFQs are long-lived and are only canceled after the expiry of the underlying instruments or the inactivity of the RFQ.

Anyone is able to participate in a GRFQ RFQ and act as a Taker or a Maker. All GRFQ RFQ Quotes, Orders, Trades, and interactions are anonymous to everyone but the users who are directly a part of each interaction.

Deribit, Bit.com, and Bybit are available as venues.

FSPD - Brief Overview

The Future Spread Dashboard (FSPD) is to be used to trade Future Spreads using a central limit Order Book. This product allows you to trade spreads as a single Strategy, priced at the Strategy level without any leg risk.

Anyone is able to participate in the Order Book of a Strategy as either a Taker or a Maker. All Orders, Trades and interactions are on an anonymous basis.

FTX, Deribit, and Bybit are available as venues.

API Connection URLs

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

Base URL | Live Environment

• RESToverHTTP: https://api.chat.paradigm.co

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

• FSPD ONLY: RESToverHTTP: https://api.fs.chat.paradigm.co

• FSPD ONLY: JSON-RPCoverWebSocket: wss://ws.api.fs.chat.paradigm.co

Base URL | Test Environment

• RESToverHTTP: https://api.test.paradigm.co

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

• FSPD ONLY: RESToverHTTP: https://api.fs.test.paradigm.co

• FSPD ONLY: JSON-RPCoverWebSocket: wss://ws.api.fs.test.paradigm.co

Product & Version

You must concatenate the Base URL with the Version & Product URLs to access specific endpoints.

• DRFQ: /v1/drfq
• GRFQ: /v1/grfq
• FSPD: /v1/fs

Examples

• DRFQ - [GET] /counterparties/ - Example: [GET] https://api.test.paradigm.co/v1/drfq/counterparties/

• DRFQ - WS Subscribe URL - Example: wss://ws.api.test.paradigm.co/v1/drfq/

• GRFQ - [GET] /rfqs/ - Example: [GET] https://api.test.paradigm.co/v1/grfq/rfqs/

• GRFQ - WS Subscribe URL - Example: wss://ws.api.test.paradigm.co/v1/grfq/

• FSPD - [GET] /instruments - Example: [GET] https://api.fs.test.paradigm.co/v1/fs/instruments

• FSPD - WS Subscribe URL - Example: wss://ws.api.fs.test.paradigm.co/v1/fs/

Rate Limits

DRFQ

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

You cannot horizontally scale your rate limit per desk by using multiple API Keys.

GRFQ

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

You cannot horizontally scale your rate limit per desk by using multiple API Keys.

FSPD

RESToverHTTP requests are rate limited per desk and by group. By default, the read-only GET requests are rate limited to 100 requests per second and all other requests, such as POST, PATCH, and DELETE are limited to 10 requests per second. Paradigm can customize these limits by desk depending on the desk's volume of operations. The desk administrator may request a limit increase by contacting support.

You cannot horizontally scale your rate limit per desk by using multiple API Keys.

On-boarding

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 can test the workflows 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 account creation by the Sales representative, enter testnet Venue API credentials to your Paradigm test Client Admin Dashboard.

As a note, you will need to enter different Venue API Credentials on your Taker and Maker Paradigm accounts as you cannot trade against yourself.

Exchange Testnet URLs

• Deribit's Testnet: test.deribit.com
• Bit.com's Testnet: beta.bitexch.dev
• Bybit's Testnet: testnet.bybit.com

Helpful Reminders

• You CANNOT RFQ, Quote, or Trade yourself across any of Paradigm's Products.
• All instruments on Paradigm are the same instruments you trade on the underlying venue. This means:
  • Instruments on Paradigm can only be traded to the minimum tick size specified by the underlying venue's contract specifications.
  • Instruments on Paradigm can only be traded to the minimum order/contract size specified by the underlying venue's contract specifications.
  • Supported Venue & Instrument Contract Specifications

High Level Implementation Notes

These notes relate to DRFQ, GRFQ, and FSPD Products.

You should use your connection to Paradigm through the JSON-RPCoverWebSockets interface to receive updates relating to RFQs, Quotes, Orders (GRFQ+FSPD), 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, Creating Orders, and Canceling Orders.

Your solution should

• For JSON-RPCoverWebSocket connections, ensure a heartbeat has been initiated and is being maintained.
• Ensure each request has the necessary authentication attributes as each request must be authenticated.
• For DRFQs, be subscribed to the rfq, quote, trade, and trade_confirmation JSON-RPCoverWebSockets Notification channels to receive updates relating to those events.
• For GRFQs, be subscribed to the grfq, quote_book, quote, order, trade, and trade_tape JSON-RPCoverWebSockets Notification channels to receive updates relating to those events.
• For FSPD, be subscribed to the strategy_state.{venue}.{kind}, order_book.{strategy_id}.{level}, trades.{venue}.{kind}.{strategy_id}, trade_tape.{venue}.{kind}.{strategy_id}, and platform_state JSON-RPCoverWebSockets Notification channels to receive updates relating to those events.
• Wait for responses to RESToverHTTP requests to confirm successful or erroneous interactions.

Your solution should not

• Use RESToverHTTP endpoints to frequently request updates relating to RFQs, Quotes, Orders (GRFQ+FSPD) or Trades.
• Use JSON-RPCoverWebSockets to send RESToverHTTP requests to Paradigm.

Market Maker Protection (MMP)

Paradigm's Market Maker Protection (MMP) program is designed to protect Makers and limits the number of executions possible across a desk across a period of time.

All of a Maker's Desk's existing Quotes will be canceled and the Maker's Desk will be prevented from creating additional Quotes if two executions occur within one second. To remove this protection, the user can send a successful RESToverHTTP [PATCH] /v1/{product}/mmp/status/ request. The MMP protection is automatically removed within 10 seconds of triggering by Paradigm without any interaction necessary by the user.

Takers are only able to execute twice every five seconds.

This feature is enabled for all Paradigm clients and cannot be disabled. The conditions of MMP being triggered cannot be configured by the user.

MMP is across all of your Desk's Paradigm API Keys. MMP protections and workflows are shared across DRFQ+GRFQ products.

This means, upon MMP being triggered by either DRFQ or GRFQ, the Maker's Desk will be unable to create any additional quotes and all existing quotes will be canceled irrespective of whether you are using DRFQ or GRFQ until a [PATCH] /v1/drfq/mmp/status/ or [PATCH] /v1/grfq/mmp/status/ request is successful. Desk interactions with FSPD will remain unaffected.

MMP functionality is not applied for FSPD.

Errors

All RESToverHTTP error responses follow the same basic format. An Error object is returned in response to an erroneous RESToverHTTP request, accompanied by an 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:

Error Codes

The following general error codes are supported by Paradigm:

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 API endpoints.

As an additional protection measure against replay attacks in environments where SSL trust is not properly configured, Paradigm requires all RESToverHTTP requests to be signed using your Paradigm API Key's <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 Venue API Keys, on the Venue, you will need to include Paradigm's IP addresses in your Venue API Key whitelists.

There are a number of Authentication methods available across both the RESToverHTTP and JSON-RPCoverWebSocket interfaces, these include:

• Token-based Authentication
• HTTP Header
• Cookie
• Query String Parameter (JSON-RPCoverWebSocket only)

Error Codes

The following error codes relate to Authentication Errors:

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.

You use the same Paradigm API <access-key> & <secret-key> to authenticate requests for all Paradigm products.

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:

1. Access Key: used to authenticate the API.
2. 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.

HTTP Header

Authorization example with an 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>

Cookie

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 Environment | URL Examples

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

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

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

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

Test Environment | URL Examples

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

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

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

FSPD - JSON-RPCoverWebSocket Connection URL: wss://ws.api.fs.test.paradigm.co/v1/fs/?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 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'/v1/drfq/instruments/?venue=DBT&asset=BTC'
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'/v1/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 your Paradigm API <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 (milliseconds 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:

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 both the role of the Client and the Server depending on the Request.

Error Codes

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

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 (solely for DRFQ), Quotes (DRFQ+GRFQ+VRFQ) and Orders (FSPD) that have been sent with the Paradigm API Key used to authenticate the WebSocket session when all associated WebSocket connections disconnect.

If multiple WebSocket connections are authenticated with the same API Key at the same time, then RFQs (solely for DRFQ), Quotes (DRFQ+GRFQ+VRFQ) and Orders (FSPD) 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 JSON-RPCoverWebSocket interface.

Live Environment | Cancel on Disconnect Examples

DRFQ - JSON-RPCoverWebSocket Connection URL: wss://ws.api.chat.paradigm.co/v1/drfq/?api-key=<access-key>&cancel_on_disconnect=false

GRFQ - JSON-RPCoverWebSocket Connection URL: wss://ws.api.chat.paradigm.co/v1/grfq/?api-key=<access-key>&cancel_on_disconnect=false

FSPD - JSON-RPCoverWebSocket Connection URL: wss://ws.api.fs.chat.paradigm.co/v1/fs/?api-key=<access-key>&cancel_on_disconnect=false

Test Environment | Cancel on Disconnect Examples

DRFQ - JSON-RPCoverWebSocket Connection URL: wss://ws.api.test.paradigm.co/v1/drfq/?api-key=<access-key>&cancel_on_disconnect=false

GRFQ - JSON-RPCoverWebSocket Connection URL: wss://ws.api.test.paradigm.co/v1/grfq/?api-key=<access-key>&cancel_on_disconnect=false

FSPD - JSON-RPCoverWebSocket Connection URL: wss://ws.api.fs.test.paradigm.co/v1/fs/?api-key=<access-key>&cancel_on_disconnect=false

Request Objects

An example of a JSON-RPCoverWebSocket Request message

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

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

The Request object has the following members:

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 an 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:

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:

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 regarding RFQs, Quotes, Orders (GRFQ+FSPD) 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:

subscribe

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"]
}

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

For GRFQ, there are six subscription channels you can subscribe to: rfq, quote_book, order, quote, trade, and trade_tape.

For VRFQ, there are three subscription channels you can subscribe to: rfq, quote, and trade.

For FSPD, there are six subscription channels you can subscribe to: strategy_state.{venue}.{kind}, order_book.{strategy_id}.{level}, orders.{venue}.{kind}.{strategy_id}, trades.{venue}.{kind}.{strategy_id}, trade_tape.{venue}.{kind}.{strategy_id}, and venue_bbo.{strategy_id}.

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 (DRFQ+GRFQ).

The Request params object has the following members:

unsubscribe

An example of an unsubscribe Request Object

{
  "id": 123,
  "jsonrpc": "2.0",
  "method": "unsubscribe",
  "params": {
    "channel": "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:

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 regarding RFQs, Quotes, Orders(GRFQ+FSPD) and Trades.

Key Note: DRFQ, GRFQ, and FSPD are separate products with separate JSON-RPCoverWebSocket subscriptions required. You must subscribe to the specific channels of each product you would like to receive notifications from.

DRFQ WebSocket Notification Channels

DRFQ JSON-RPCoverWebSocket notification channels are:

• rfq - Private Updates relating to the creation, expiration, cancellation and fill of RFQs.
• quote - Private Updates relating to RFQ quotes including creation, expiration, cancellation, pending_fill and fills of.
• trade - Public Updates regarding all completed DRFQ trades on Paradigm even if you are not an included counterparty.
• trade_confirmation - Private Updates relating to the successful clearing & settlements of trades upon the underlying venue.
• market_maker_protection - Private Updates relating to Market Maker Protection being triggered.

GRFQ WebSocket Notification Channels

GRFQ JSON-RPCoverWebSocket notification channels are:

• rfq - Public Updates relating to the creation and expiration of RFQs.
• quote_book - Public Updates relating to the creation and availability of Quotes.
• order - Private Updates relating to the creation and execution of Orders upon Quotes.
• quote - Private Updates relating to creation, execution, and cancellation of Quotes upon RFQs.
• trade - Private Updates relating to executions solely involving the Taker and Maker.
• trade_tape - Public Updates relating to all completed Trades on Paradigm through GRFQ.
• market_maker_protection - Private Updates relating to Market Maker Protection being triggered.

VRFQ WebSocket Notification Channels

VRFQ JSON-RPCoverWebSocket notification channels are:

• rfq - Public Updates relating to the creation and expiration of RFQs.
• quote - Private Updates relating to creation, execution, and cancellation of Quotes upon RFQs.
• trade - Private Updates relating to executions solely involving the Taker and Maker.

FSPD WebSocket Notification Channels

FSPD JSON-RPCoverWebSocket notification channels are:

• strategy_state.{venue}.{kind} - Public Updates relating to the creation, settlement, and expiration of Strategies.
• order_book.{strategy_id}.{level} - Public Updates relating to delta of Orders being added and removed from the Order Book.
• orders.{venue}.{kind}.{strategy_id} - Private Updates relating to the creation, cancellation and interactions of the user's Orders.
• trades.{venue}.{kind}.{strategy_id} - Private Updates relating to success or rejected of the user's Trades.
• trade_tape.{venue}.{kind}.{strategy_id} - Public Updates relating to all completed Trades on Paradigm through FSPD.
• venue_bbo.{strategy_id} - Public Updates relating to the prices+amounts of the Strategies from the underlying venue.

Shared - REST Endpoints

The following REST Endpoints have no Product Identifier in the Connection URL as they are shared across the Paradigm API.

[POST] /echo/

/echo/ Request example

# You can also use wget
curl -X POST https://api.test.paradigm.co/v1/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.test.paradigm.co/v1/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 = '/v1/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 <acces-key>"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := https.NewRequest("POST", "https://api.test.paradigm.co/v1/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 to allow users to test their authentication as well as connection to Paradigm's API.

Parameters

Response Schema

Status Code 200

Shared - WebSocket Notification Channels

market_maker_protection

An example of MMP being triggered

{
  "jsonrpc": "2.0",
  "method": "subscription",
  "params": {
    "channel": "market_maker_protection",
    "data": {
      "kind": "TRIGGERED"
    }
  }
}

An update is sent to the market_maker_protection WebSocket Notification Channel when MMP has been triggered. There is no message when it has been reset.

You must subscribe to this channel using the Connection URL with the Version and Product URL suffix of the respective products below. For example: wss://ws.api.test.paradigm.co/v1/grfq.

If MMP is triggered from the DRFQ product, you will be notified on the market_maker_protection channel even if you subscribed using the GRFQ Version and Product URL.

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

DRFQ - API Workflows

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 a part of the 'LP' counterparty list returned from [GET] /counterparties/.

DRFQ will be sunset & deprecated in the future with DRFQv2 taking it's place. Dates will be communicated in advance & DRFQ will be backwards compatible with DRFQv2 for a reasonable period.

High Level

DRFQ is centred around the concepts of "RFQs", "Quotes" and "Trades":

• RFQs are strategies comprised of one or more instruments with Taker defined attributes. RFQs are to be Quoted upon by the requested Makers.
• Quotes are created by the Maker in response to a requested RFQ.
• Trades occur when the Taker executes upon an existing Quote on an RFQ.

At a high level, the DRFQ workflow is:

1. Taker creates an RFQ and chooses which counterparties to send it too.
2. Maker(s) quotes the RFQ.
3. Taker receives the quote(s).
4. Taker chooses to execute upon the best quote and the trade is sent to the underlying venue for clearing & settlement.
5. Taker & Maker receive confirmation that the trade's execution has successfully cleared & settled or been rejected by the underlying venue.

Key DRFQ Concepts

In DRFQ,

• Specific counterparties must be selected by the Taker to participate in the RFQ.
• There are NO partial fills. You must quote and execute the full RFQ size.
• There is NO concept of a Quote Book or a public auction.
• Takers can choose to RFQ on a disclosed or an anonymous basis.
• It is possible to have an execution Rejected by the underlying venue for a number of reasons (eg, Margin or API Key issues).

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.

1. Taker creates an RFQ using [POST] /rfq/create/. You can pull available instruments from [GET] /instruments/ and counterparties from [GET] /counterparties/.
2. Taker is able to cancel an RFQ if they wish to do so with [POST] /rfq/cancel/.
3. 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.
4. Taker, who will be notified of quotes on the quote JSON-RPCoverWebSockets Notification channel, is able to execute upon the best quote with [POST] /quote/execute/.
5. Taker will receive confirmation of the trade's successful/rejected clearing & settlement on the trade_confirmation JSON-RPCoverWebSockets Notification channel.
6. Taker will also receive confirmation of the trade being completed on the trade JSON-RPCoverWebSockets Notification channel as well as all other DRFQ trades on Paradigm.

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.

1. Taker will create an RFQ and the Maker will be notified on the rfq JSON-RPCoverWebSockets Notification channel.
2. Maker is able to create a one way quote using [POST] /quote/create/.
3. Maker is able to cancel an existing quote with [POST] /quote/cancel/. A Maker must cancel any existing quote on an RFQ before they are able to update their quote.
4. Taker chooses to execute upon an available quote.
5. Maker will receive an update of their Quote being executed upon from the quote JSON-RPCoverWebSockets Notification channel with the status pending_fill.
6. Maker will receive finality around successful/rejected clearing & settlement from the trade_confirmation JSON-RPCoverWebSockets Notification channel.
7. Maker will receive confirmation of the trade being completed on the trade JSON-RPCoverWebSockets Notification channel as well as all other DRFQ trades on Paradigm.

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

DRFQ will be sunset & deprecated in the future with DRFQv2 taking it's place. Dates will be communicated in advance & DRFQ will be backwards compatible with DRFQv2 for a reasonable period.

Note: All examples in this section are in Python3.

JSON-RPCoverWebSockets

Authentication + Subscribe & Unsubscribe to Notification Channels

1. 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

1. [GET] - /instruments/ - A simple code example demonstrating how to pull the instruments available on Paradigm.
2. [GET] - /counterparties/ - A simple code example demonstrating how to pull your available counterparties' information.
3. [GET] - /rfq/ - A simple code example demonstrating how to pull information relating to RFQs you are a participant in.
4. [GET] - /rfq/ - A more comprehensive example demonstrating pagination and the use of parameters.

Taker Specific

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

Maker Specific

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

Auto-Market Makers

We encourage you to RFQ all counterparties marked as an "LP" from the [GET] /counterparties/ as this includes all of Paradigm's Auto-Market Makers.

The desk names of some 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/python/api/drfq/market_maker

Auto-Takers

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

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

DRFQ - WebSocket Notification Channels

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,
      "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,
      "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,
      "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
    }
  }
}

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

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

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:

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": null,
      "created": 1611024112328.771,
      "legs": [
        {
          "price": null,
          "quantity": 25.0,
          "instrument": "BTC-19JAN21-32000-C",
          "side": "SELL",
          "venue": "DBT"
        },
        {
          "price": null,
          "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": null,
      "account": {
        "name": "ParadigmTestOne"
      },
      "client_order_id": "DSK1738007604",
      "created": 1611024112328.771,
      "legs": [
        {
          "price": null,
          "quantity": 25.0,
          "instrument": "BTC-19JAN21-32000-C",
          "side": "SELL",
          "venue": "DBT"
        },
        {
          "price": null,
          "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.

The response params data object has the following members:

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:

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:

DRFQ - REST Endpoints

[GET] /instruments/

/instruments/ Request example

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

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

fetch("https://api.test.paradigm.co/v1/drfq/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

# 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 = '/v1/drfq/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", "https://api.test.paradigm.co/v1/drfq/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 venue they are traded upon.

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

Parameters

/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"
    }
  ]
}

Response Schema

Status Code 200

Error Codes

[GET] /counterparties/

/counterparties/ Request example

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

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

fetch("https://api.test.paradigm.co/v1/drfq/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

# 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 = '/v1/drfq/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", "https://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

/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"]
    }
  ]
}