IronbeamAPI (2.1)

Ironbeam API

This API describes the Ironbeam API. Using this API, you can access the following functionality:

• Authentication
• Account Information
• Account Risk
• Account Positions
• Account Balance
• Account Fills
• Account Orders
• Account Order Fills
• Account Order Stream
• Market Data
• Order Management
• Streaming Data
• Symbol Search
• Security Information
• Entitled Exchanges
• Exchange Sources
• Market Complexes
• Demo Account Management

---

API Design

The API is organized around REST. Our API has predictable resource-oriented URLs, accepts form-encoded request bodies, returns JSON-encoded responses, and uses standard HTTP response codes, authentication, and verbs. Authentication is done via Bearer token. To obtain a token, you must first authenticate using the /auth endpoint. The token is then used in the Authorization header of all subsequent requests. The API is designed to have predictable, resource-oriented URLs and to use HTTP response codes to indicate API errors. We use built-in HTTP features, like HTTP authentication and HTTP verbs, which are understood by off-the-shelf HTTP clients. We support cross-origin resource sharing, allowing you to interact securely with our API from a client-side web application (though you should never expose your secret API key in any public website's client-side code). You can read more about how to use the API in our documentation.

---

API Usage

To use this API you can generate a client library in your preferred language using the OpenAPI specification file provided here. The OpenAPI specification file is a machine-readable file that describes the API in a standard way. You can use this file to generate a client library in your preferred language using a tool like Swagger UI or OpenAPI Generator. You can also use the OpenAPI specification file to generate documentation for the API using a tool like Swagger UI.

Generating a client library with OpenAPI Generator

Example how to generate client library using OpenAPI Generator:

Step 1: Install openapi-generator-cli

You can install openapi-generator-cli globally using npm:

npm install @openapitools/openapi-generator-cli -g

Or you can install it locally in your project:

npm install @openapitools/openapi-generator-cli --save-dev

Important: You must have Java 8 or later installed on your system to use OpenAPI Generator.

Full installation instructions can be found on the OpenAPI Generator website.

Step 2: Generate Client Code

For C#

openapi-generator-cli generate -i openapi.json -g csharp -o ./csharp-client

This will generate a C# client in the ./csharp-client directory.
For C# you can also use the NSwag or NSWagStudio to generate a client library with a graphical user interface.

For TypeScript

openapi-generator-cli generate -i openapi.json -g typescript-angular -o ./typescript-client

or

openapi-generator-cli generate -i openapi.json -g typescript -o ./typescript-client

or

openapi-generator-cli generate -i openapi.json -g typescript-fetch -o ./typescript-client

or

openapi-generator-cli generate -i openapi.json -g typescript-axios -o ./typescript-client

This will generate a TypeScript client in the ./typescript-client directory.

For Python

openapi-generator-cli generate -i openapi.json -g python -o ./python-client

This will generate a Python client in the ./python-client directory.

For PHP

openapi-generator-cli generate -i openapi.json -g php -o ./php-client

This will generate a PHP client in the ./php-client directory.

For Java

openapi-generator-cli generate -i openapi.json -g java -o ./java-client

This will generate a Java client in the ./java-client directory.

For JavaScript

openapi-generator-cli generate -i openapi.json -g javascript -o ./javascript-client

This will generate a JavaScript client in the ./javascript-client directory.

In these commands:

• -i openapi.json - specifies the input OpenAPI definition file.Witch can be downloaded at top of this documentation.
• -g - specifies the language generator. You can replace csharp, typescript, typescript-angular, typescript-fetch, typescript-axios, python, php, java, or javascript with other language generators supported by OpenAPI Generator.
• -o ./[language]-client specifies the output directory where the generated client code will be saved.

Please replace openapi.json with your actual OpenAPI definition file name downloaded from this page.

Remember, you should handle exceptions as necessary, especially for network operations. This code also assumes that you’re using the async/await pattern for asynchronous programming. If you’re not, you’ll need to adjust the code accordingly. Also, remember to dispose of the HttpClient when you’re done with it to free up network resources.

Generating client and documentation with Swagger UI

You can use the OpenAPI specification file to generate documentation for the API using Swagger UI. Swagger UI is a collection of HTML, JavaScript, and CSS assets that dynamically generate beautiful documentation from a Swagger-compliant API. You can use Swagger UI to generate interactive API documentation that lets you try out the API calls directly in the browser (you can install Swagger UI locally or use the online version hosted by Swagger). You can find more information about Swagger UI here. This will generate a client library for the API in different languages. You can use the client library to interact with the API in your preferred language. Swagger UI will generate documentation and examples for the API that you can use to understand how the API works and how to use it. You can use the documentation to learn about the API and to build applications that use the API.

---

Streaming

For streaming data, we use WebSockets. To use streaming data, you must first create a streamId using the /stream/create endpoint. You can then use the streamId to subscribe to quotes, depth, and trades using the /stream/{streamId} endpoint. The /stream/{streamId} endpoint will return a WebSocket stream of data to the client. To open a WebSocket connection to the /stream/{streamId} endpoint, you must use the streamId as a parameter in the URL. For example, to open a WebSocket connection to the /stream/{streamId} endpoint, you would use the following URL: wss://demo.ironbeamapi.com/v2/stream/{streamId}. Remember to include the token in the query of the request to authenticate the client. You can use the token that you obtained when you authenticated using the /auth endpoint.

Important:

• Before calling the /stream/{streamId} endpoint, you must create a streamId using the /stream/create endpoint.
• Each time the WebSocket connection is closed, you must call the /stream/create endpoint to create a new streamId.
• You can then use the new streamId to open a new WebSocket connection to the /stream/{streamId} endpoint.
• While opening a WebSocket connection use WSS schema: wss://demo.ironbeamapi.com/v2/stream/{streamId}?token={token}

Example in Python

import requests
import websocket
import json

def on_message(ws, message):
    print(f"Received: {message}")
def on_error(ws, error):
    print(f"Error: {error}")
def on_close(ws):
    print("Connection closed")
def on_open(ws):
    print("Connection opened")
# Call the authorization endpoint to get a token
auth_response = requests.post("https://demo.ironbeamapi.com/v2/auth", data={"username": "your_username", "password": "your_password"})
token = auth_response.json()['token']
# Call /stream/create to get a streamId
stream_response = requests.get("https://demo.ironbeamapi.com/v2/stream/create", headers={"Authorization": f"Bearer {token}"})
streamId = stream_response.json()['streamId']
# Open a WebSocket connection with the bearer token and streamId
ws = websocket.WebSocketApp(
    f"wss://demo.ironbeamapi.com/v2/stream/{streamId}?token={token}",
    on_message=on_message,
    on_error=on_error,
    on_close=on_close,
)
ws.on_open = on_open
ws.run_forever()

Example in JavaScript

// Call the authorization endpoint to get a token
fetch('https://demo.ironbeamapi.com/v2/auth', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    username: 'your_username',
    password: 'your_password',
  }),
})
.then(response => response.json())
.then(data => {
  const token = data.token;
  
  // Call /stream/create to get a streamId
  fetch('https://demo.ironbeamapi.com/v2/stream/create', {
    method: 'POST',
    headers: {
      'Authorization': Bearer ${token},
    },
  })
  .then(response => response.json())
  .then(data => {
    const streamId = data.streamId;
// Open a WebSocket connection with the bearer token as query parameter and streamId
const socket = new WebSocket(`wss://demo.ironbeamapi.com/v2/stream/${streamId}?token=${token}`);

socket.onopen = function(e) {
  console.log("Connection opened");          
};

socket.onmessage = function(event) {
  console.log(`Received: ${event.data}`);
};

socket.onerror = function(error) {
  console.log(`Error: ${error.message}`);
};

socket.onclose = function(event) {
  if (event.wasClean) {
    console.log(`Connection closed cleanly, code=${event.code} reason=${event.reason}`);
  } else {
    console.log('Connection died');
  }
};

  });
});

Example in C#

  using System;
  using System.Net.Http;
  using System.Net.WebSockets;
  using System.Text;
  using System.Text.Json;
  using System.Threading;
  using System.Threading.Tasks;
      
  public class Program
  {
      public static async Task Main(string[] args)
      {
          var httpClient = new HttpClient();
      // Call the authorization endpoint to get a token
      var authResponse = await httpClient.PostAsync("https://demo.ironbeamapi.com/v2/auth", new StringContent(JsonSerializer.Serialize(new { username = "your_username", password = "your_password" }), Encoding.UTF8, "application/json"));
      var authData = JsonSerializer.Deserialize<Dictionary<string, string>>(await authResponse.Content.ReadAsStringAsync());
      var token = authData["token"];
  
      // Call /stream/create to get a streamId
      var streamResponse = await httpClient.PostAsync("https://demo.ironbeamapi.com/v2/stream/create", new StringContent("", Encoding.UTF8, "application/json"));
      var streamData = JsonSerializer.Deserialize<Dictionary<string, string>>(await streamResponse.Content.ReadAsStringAsync());
      var streamId = streamData["streamId"];
  
      // Open a WebSocket connection with the bearer token and streamId
      var webSocket = new ClientWebSocket();
      
  
      var uri = new Uri($"wss://demo.ironbeamapi.com/v2/stream/{streamId}?token={token}");
      var cts = new CancellationTokenSource();
  
      await webSocket.ConnectAsync(uri, cts.Token);
  
      Console.WriteLine("Connection opened");
      // Now you can use the webSocket object to send and receive messages
  }

  }

---

API Versioning

We use a versioning scheme that allows you to specify which version of the API you want to use. To specify the version of the API you want to use, you include the version number in the URL. For example, to use version 1 of the API, you would use the following URL: https://demo.ironbeamapi.com/v1.

---

Change log

- 1.0: Initial version