Buying Units Programmatically

Start interacting with our Trading API to buy units programmatically using the following steps.

Send your first Trading API request

Generate a Key Pair

from nacl.signing import SigningKey
import base64

private_key = SigningKey.generate()
public_key = private_key.verify_key

private_key_b64 = base64.b64encode(bytes(private_key)).decode()
public_key_b64 = base64.b64encode(bytes(public_key)).decode()

print(f'Private Key: {private_key_b64}')
print(f'Public Key: {public_key_b64}')

import nacl from 'tweetnacl';
import util from 'tweetnacl-util';

const keyPair = nacl.sign.keyPair();
const privateKey = util.encodeBase64(keyPair.secretKey);
const publicKey = util.encodeBase64(keyPair.publicKey);

console.log('Private Key:', privateKey);
console.log('Public Key:', publicKey);

package main

import (
	"crypto/ed25519"
	"crypto/rand"
	"encoding/base64"
	"fmt"
)

func main() {
	publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		panic(err)
	}

	privateKeyB64 := base64.StdEncoding.EncodeToString(privateKey.Seed())
	publicKeyB64 := base64.StdEncoding.EncodeToString(publicKey)

	fmt.Println("Private Key:", privateKeyB64)
	fmt.Println("Public Key:", publicKeyB64)
	fmt.Println("Register this public key via the app or API.")
}

Register the Public Key

Open your app and head to API Keys. Follow the following steps to register your API key and obtain a fingerprint for that key.

[Insert Product Screenshots]

Choose an instrument, and send a buy order

Use the fingerprint in the following script to Market or Limit Buy 1 Unit of your chosen Instrument (Chat Fast or Chat Prime).

Chat Fast: suited for latency-sensitive UX, high throughput, instantaneous responses
Chat Prime: suited for higher reasoning quality, thoughtful or calculative responses, deeper workflows

Read more about Current Instruments to guide your decision.

import base64
import json
import os
import time

import requests
from nacl.signing import SigningKey

BASE_URL = "https://trading.api.thegrid.ai"


class SignatureAuth:
    def __init__(self, private_key_b64, fingerprint):
        self.private_key = SigningKey(base64.b64decode(private_key_b64)[:32])
        self.fingerprint = fingerprint

    def get_headers(self, method, path, body=""):
        timestamp = str(int(time.time()))
        message = f"{timestamp}{method.upper()}{path}{body}"
        signature = self.private_key.sign(message.encode()).signature
        return {
            "x-thegrid-signature": base64.b64encode(signature).decode(),
            "x-thegrid-timestamp": timestamp,
            "x-thegrid-fingerprint": self.fingerprint,
        }


auth = SignatureAuth(
    os.environ["GRID_TRADING_PRIVATE_KEY"],
    os.environ["GRID_TRADING_FINGERPRINT"],
)

order_data = {
    "market_id": "market_788dcbd5-ac68-4c61-acf1-4443beaf2a1c",
    "side": "buy",
    "type": "limit",
    "quantity": 1,
    "price": "2.50",
    "time_in_force": "gtc",
    "client_order_id": f"buy-{int(time.time())}",
}

path = "/api/v1/trading/orders"
body = json.dumps(order_data)
headers = auth.get_headers("POST", path, body)
headers["Content-Type"] = "application/json"

response = requests.post(f"{BASE_URL}{path}", data=body, headers=headers)
response.raise_for_status()

print("Order ID:", response.json()["data"]["order_id"])

// Buy Instrument Unit (Trading API)

import axios from 'axios';
import nacl from 'tweetnacl';
import util from 'tweetnacl-util';

function decodePrivateKey(privateKeyBase64) {
  const raw = util.decodeBase64(privateKeyBase64);
  if (raw.length === nacl.sign.seedLength) {
    return nacl.sign.keyPair.fromSeed(raw).secretKey;
  }
  if (raw.length === nacl.sign.secretKeyLength) {
    return raw;
  }
  throw new Error('Invalid private key length; expected 32-byte seed or 64-byte secret key');
}

const BASE_URL = 'https://trading.api.thegrid.ai';

class SignatureAuth {
  constructor(privateKeyBase64, fingerprint) {
    this.privateKey = decodePrivateKey(privateKeyBase64);
    this.fingerprint = fingerprint;
  }

  getHeaders(method, path, body = '') {
    const timestamp = Math.floor(Date.now() / 1000).toString();
    const message = `${timestamp}${method.toUpperCase()}${path}${body}`;
    const messageBytes = util.decodeUTF8(message);
    const signatureBytes = nacl.sign.detached(messageBytes, this.privateKey);
    return {
      'x-thegrid-signature': util.encodeBase64(signatureBytes),
      'x-thegrid-timestamp': timestamp,
      'x-thegrid-fingerprint': this.fingerprint
    };
  }
}

const auth = new SignatureAuth(
  process.env.GRID_TRADING_PRIVATE_KEY,
  process.env.GRID_TRADING_FINGERPRINT
);

const orderData = {
  market_id: 'market_788dcbd5-ac68-4c61-acf1-4443beaf2a1c',
  side: 'buy',
  type: 'limit',
  quantity: 1,
  price: '2.50',
  time_in_force: 'gtc',
  client_order_id: `buy-${Date.now()}`
};

const path = '/api/v1/trading/orders';
const body = JSON.stringify(orderData);
const response = await axios.post(`${BASE_URL}${path}`, body, {
  headers: {
    'Content-Type': 'application/json',
    ...auth.getHeaders('POST', path, body)
  }
});

console.log('Order ID:', response.data.data.order_id);

package main

import (
	"bytes"
	"crypto/ed25519"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"strconv"
	"time"
)

const baseURL = "https://trading.api.thegrid.ai"

type SignatureAuth struct {
	privateKey  ed25519.PrivateKey
	fingerprint string
}

func NewSignatureAuth(privateKeyB64, fingerprint string) *SignatureAuth {
	privateKeyBytes, _ := base64.StdEncoding.DecodeString(privateKeyB64)
	var privateKey ed25519.PrivateKey
	if len(privateKeyBytes) == ed25519.SeedSize {
		privateKey = ed25519.NewKeyFromSeed(privateKeyBytes)
	} else {
		privateKey = ed25519.PrivateKey(privateKeyBytes)
	}

	return &SignatureAuth{privateKey: privateKey, fingerprint: fingerprint}
}

func (sa *SignatureAuth) GetHeaders(method, path, body string) map[string]string {
	timestamp := strconv.FormatInt(time.Now().Unix(), 10)
	message := timestamp + method + path + body
	signature := ed25519.Sign(sa.privateKey, []byte(message))
	return map[string]string{
		"x-thegrid-signature":   base64.StdEncoding.EncodeToString(signature),
		"x-thegrid-timestamp":   timestamp,
		"x-thegrid-fingerprint": sa.fingerprint,
	}
}

func main() {
	auth := NewSignatureAuth(
		os.Getenv("GRID_TRADING_PRIVATE_KEY"),
		os.Getenv("GRID_TRADING_FINGERPRINT"),
	)

	orderData := map[string]any{
		"market_id":       "market_788dcbd5-ac68-4c61-acf1-4443beaf2a1c",
		"side":            "buy",
		"type":            "limit",
		"quantity":        1,
		"price":           "2.50",
		"time_in_force":   "gtc",
		"client_order_id": fmt.Sprintf("buy-%d", time.Now().Unix()),
	}

	orderJSON, err := json.Marshal(orderData)
	if err != nil {
		log.Fatal(err)
	}

	path := "/api/v1/trading/orders"
	req, err := http.NewRequest("POST", baseURL+path, bytes.NewBuffer(orderJSON))
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Content-Type", "application/json")
	for k, v := range auth.GetHeaders("POST", path, string(orderJSON)) {
		req.Header.Set(k, v)
	}

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	var result struct {
		Data struct {
			OrderID string `json:"order_id"`
		} `json:"data"`
	}
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		log.Fatal(err)
	}

	fmt.Println("Order ID:", result.Data.OrderID)
}

See the Unit transferred to your Consumption Account

Note: Today, Units bought in your Trading Account transfer to your Consumption Account automatically. You can use this script to check the Units that have been transferred to your Consumption account and are active.

import base64
import os
import time

import requests
from nacl.signing import SigningKey

BASE_URL = "https://trading.api.thegrid.ai"


class SignatureAuth:
    def __init__(self, private_key_b64, fingerprint):
        self.private_key = SigningKey(base64.b64decode(private_key_b64)[:32])
        self.fingerprint = fingerprint

    def get_headers(self, method, path, body=""):
        timestamp = str(int(time.time()))
        message = f"{timestamp}{method.upper()}{path}{body}"
        signature = self.private_key.sign(message.encode()).signature
        return {
            "x-thegrid-signature": base64.b64encode(signature).decode(),
            "x-thegrid-timestamp": timestamp,
            "x-thegrid-fingerprint": self.fingerprint,
        }


auth = SignatureAuth(
    os.environ["GRID_TRADING_PRIVATE_KEY"],
    os.environ["GRID_TRADING_FINGERPRINT"],
)

# Consumption accounts
consumption_path = "/api/v1/trading/consumption-accounts"
consumption_resp = requests.get(
    f"{BASE_URL}{consumption_path}?order_by=created_at",
    headers=auth.get_headers("GET", consumption_path),
)
consumption_resp.raise_for_status()

print("=== Consumption Accounts ===")
for acct in consumption_resp.json()["data"]:
    print(
        f"{acct['account_id']}: {acct['available_balance']} available, {acct['total_balance']} total (instrument {acct['instrument_id']})"
    )

import axios from 'axios';
import nacl from 'tweetnacl';
import util from 'tweetnacl-util';

function decodePrivateKey(privateKeyBase64) {
  const raw = util.decodeBase64(privateKeyBase64);
  if (raw.length === nacl.sign.seedLength) {
    return nacl.sign.keyPair.fromSeed(raw).secretKey;
  }
  if (raw.length === nacl.sign.secretKeyLength) {
    return raw;
  }
  throw new Error('Invalid private key length; expected 32-byte seed or 64-byte secret key');
}

const BASE_URL = 'https://trading.api.thegrid.ai';

class SignatureAuth {
  constructor(privateKeyBase64, fingerprint) {
    this.privateKey = decodePrivateKey(privateKeyBase64);
    this.fingerprint = fingerprint;
  }

  getHeaders(method, path, body = '') {
    const timestamp = Math.floor(Date.now() / 1000).toString();
    const message = `${timestamp}${method.toUpperCase()}${path}${body}`;
    const messageBytes = util.decodeUTF8(message);
    const signatureBytes = nacl.sign.detached(messageBytes, this.privateKey);
    return {
      'x-thegrid-signature': util.encodeBase64(signatureBytes),
      'x-thegrid-timestamp': timestamp,
      'x-thegrid-fingerprint': this.fingerprint
    };
  }
}

const auth = new SignatureAuth(
  process.env.GRID_TRADING_PRIVATE_KEY,
  process.env.GRID_TRADING_FINGERPRINT
);

// Consumption accounts
const consumptionPath = '/api/v1/trading/consumption-accounts';
const consumptionResp = await axios.get(`${BASE_URL}${consumptionPath}?order_by=created_at`, {
  headers: auth.getHeaders('GET', consumptionPath)
});

console.log('=== Consumption Accounts ===');
for (const acct of consumptionResp.data.data) {
  console.log(`${acct.account_id}: ${acct.available_balance} available, ${acct.total_balance} total (instrument ${acct.instrument_id})`);
}

package main

import (
	"crypto/ed25519"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"strconv"
	"time"
)

const baseURL = "https://trading.api.thegrid.ai"

type SignatureAuth struct {
	privateKey  ed25519.PrivateKey
	fingerprint string
}

func NewSignatureAuth(privateKeyB64, fingerprint string) *SignatureAuth {
	privateKeyBytes, _ := base64.StdEncoding.DecodeString(privateKeyB64)
	var privateKey ed25519.PrivateKey
	if len(privateKeyBytes) == ed25519.SeedSize {
		privateKey = ed25519.NewKeyFromSeed(privateKeyBytes)
	} else {
		privateKey = ed25519.PrivateKey(privateKeyBytes)
	}

	return &SignatureAuth{privateKey: privateKey, fingerprint: fingerprint}
}

func (sa *SignatureAuth) GetHeaders(method, path, body string) map[string]string {
	timestamp := strconv.FormatInt(time.Now().Unix(), 10)
	message := timestamp + method + path + body
	signature := ed25519.Sign(sa.privateKey, []byte(message))
	return map[string]string{
		"x-thegrid-signature":   base64.StdEncoding.EncodeToString(signature),
		"x-thegrid-timestamp":   timestamp,
		"x-thegrid-fingerprint": sa.fingerprint,
	}
}

func main() {
	auth := NewSignatureAuth(
		os.Getenv("GRID_TRADING_PRIVATE_KEY"),
		os.Getenv("GRID_TRADING_FINGERPRINT"),
	)

	// Consumption accounts
	consumptionPath := "/api/v1/trading/consumption-accounts"
	req0, err := http.NewRequest("GET", baseURL+consumptionPath+"?order_by=created_at", nil)
	if err != nil {
		log.Fatal(err)
	}
	for k, v := range auth.GetHeaders("GET", consumptionPath, "") {
		req0.Header.Set(k, v)
	}

	resp0, err := http.DefaultClient.Do(req0)
	if err != nil {
		log.Fatal(err)
	}
	defer resp0.Body.Close()

	var consumptionResult struct {
		Data []struct {
			AccountID        string      `json:"account_id"`
			InstrumentID     string      `json:"instrument_id"`
			AvailableBalance json.Number `json:"available_balance"`
			TotalBalance     json.Number `json:"total_balance"`
		} `json:"data"`
	}
	if err := json.NewDecoder(resp0.Body).Decode(&consumptionResult); err != nil {
		log.Fatal(err)
	}

	fmt.Println("=== Consumption Accounts ===")
	for _, acct := range consumptionResult.Data {
		fmt.Printf("%s: %s available, %s total (instrument %s)\n", acct.AccountID, acct.AvailableBalance.String(), acct.TotalBalance.String(), acct.InstrumentID)
	}
}

Use our Onboarding Guides for ready-to-go scripts to automate your buying and inference consumption on The Grid. These scripts cover common use cases for production implementation.
To ensure performant and efficient service, follow our Best Practices for moving your workloads from other inference providers/aggregators to The Grid

PreviousGetting started as a Consumer NextSupplying to The Grid

Last updated 10 days ago

Was this helpful?

package main import ( "bytes" "crypto/ed25519" "encoding/base64" "encoding/json" "fmt" "log" "net/http" "os" "strconv" "time" ) const baseURL = "https://trading.api.thegrid.ai" type SignatureAuth struct { privateKey ed25519.PrivateKey fingerprint string } func NewSignatureAuth(privateKeyB64, fingerprint string) *SignatureAuth { privateKeyBytes, _ := base64.StdEncoding.DecodeString(privateKeyB64) var privateKey ed25519.PrivateKey if len(privateKeyBytes) == ed25519.SeedSize { privateKey = ed25519.NewKeyFromSeed(privateKeyBytes) } else { privateKey = ed25519.PrivateKey(privateKeyBytes) } return &SignatureAuth{privateKey: privateKey, fingerprint: fingerprint} } func (sa *SignatureAuth) GetHeaders(method, path, body string) map[string]string { timestamp := strconv.FormatInt(time.Now().Unix(), 10) message := timestamp + method + path + body signature := ed25519.Sign(sa.privateKey, []byte(message)) return map[string]string{ "x-thegrid-signature": base64.StdEncoding.EncodeToString(signature), "x-thegrid-timestamp": timestamp, "x-thegrid-fingerprint": sa.fingerprint, } } func main() { auth := NewSignatureAuth( os.Getenv("GRID_TRADING_PRIVATE_KEY"), os.Getenv("GRID_TRADING_FINGERPRINT"), ) orderData := map[string]any{ "market_id": "market_788dcbd5-ac68-4c61-acf1-4443beaf2a1c", "side": "buy", "type": "limit", "quantity": 1, "price": "2.50", "time_in_force": "gtc", "client_order_id": fmt.Sprintf("buy-%d", time.Now().Unix()), } orderJSON, err := json.Marshal(orderData) if err != nil { log.Fatal(err) } path := "/api/v1/trading/orders" req, err := http.NewRequest("POST", baseURL+path, bytes.NewBuffer(orderJSON)) if err != nil { log.Fatal(err) } req.Header.Set("Content-Type", "application/json") for k, v := range auth.GetHeaders("POST", path, string(orderJSON)) { req.Header.Set(k, v) } resp, err := http.DefaultClient.Do(req) if err != nil { log.Fatal(err) } defer resp.Body.Close() var result struct { Data struct { OrderID string `json:"order_id"` } `json:"data"` } if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { log.Fatal(err) } fmt.Println("Order ID:", result.Data.OrderID) }

package main import ( "crypto/ed25519" "encoding/base64" "encoding/json" "fmt" "log" "net/http" "os" "strconv" "time" ) const baseURL = "https://trading.api.thegrid.ai" type SignatureAuth struct { privateKey ed25519.PrivateKey fingerprint string } func NewSignatureAuth(privateKeyB64, fingerprint string) *SignatureAuth { privateKeyBytes, _ := base64.StdEncoding.DecodeString(privateKeyB64) var privateKey ed25519.PrivateKey if len(privateKeyBytes) == ed25519.SeedSize { privateKey = ed25519.NewKeyFromSeed(privateKeyBytes) } else { privateKey = ed25519.PrivateKey(privateKeyBytes) } return &SignatureAuth{privateKey: privateKey, fingerprint: fingerprint} } func (sa *SignatureAuth) GetHeaders(method, path, body string) map[string]string { timestamp := strconv.FormatInt(time.Now().Unix(), 10) message := timestamp + method + path + body signature := ed25519.Sign(sa.privateKey, []byte(message)) return map[string]string{ "x-thegrid-signature": base64.StdEncoding.EncodeToString(signature), "x-thegrid-timestamp": timestamp, "x-thegrid-fingerprint": sa.fingerprint, } } func main() { auth := NewSignatureAuth( os.Getenv("GRID_TRADING_PRIVATE_KEY"), os.Getenv("GRID_TRADING_FINGERPRINT"), ) // Consumption accounts consumptionPath := "/api/v1/trading/consumption-accounts" req0, err := http.NewRequest("GET", baseURL+consumptionPath+"?order_by=created_at", nil) if err != nil { log.Fatal(err) } for k, v := range auth.GetHeaders("GET", consumptionPath, "") { req0.Header.Set(k, v) } resp0, err := http.DefaultClient.Do(req0) if err != nil { log.Fatal(err) } defer resp0.Body.Close() var consumptionResult struct { Data []struct { AccountID string `json:"account_id"` InstrumentID string `json:"instrument_id"` AvailableBalance json.Number `json:"available_balance"` TotalBalance json.Number `json:"total_balance"` } `json:"data"` } if err := json.NewDecoder(resp0.Body).Decode(&consumptionResult); err != nil { log.Fatal(err) } fmt.Println("=== Consumption Accounts ===") for _, acct := range consumptionResult.Data { fmt.Printf("%s: %s available, %s total (instrument %s)\n", acct.AccountID, acct.AvailableBalance.String(), acct.TotalBalance.String(), acct.InstrumentID) } }

Good afternoon

hashtagSend your first Trading API request

hashtagGenerate a Key Pair

hashtagRegister the Public Key

hashtagChoose an instrument, and send a buy order

hashtagSee the Unit transferred to your Consumption Account

Send your first Trading API request

Generate a Key Pair

Register the Public Key

Choose an instrument, and send a buy order

See the Unit transferred to your Consumption Account