Kraken Getting Started: API Access & First Request (2026)

Getting started overview

Getting started with the Kraken API involves a series of steps designed to ensure secure and authorized access to its trading and market data services. This guide focuses on the initial setup, including account creation, identity verification, API key generation, and executing a foundational API request. The Kraken API supports both REST and WebSocket protocols, providing interfaces for spot trading, futures, staking, and asset management. Users can interact with the API directly via HTTP requests or through official and community-contributed SDKs available in multiple programming languages, including Python and Node.js.

The process generally begins with establishing a Kraken account and completing the necessary identity verification steps. Following successful verification, API keys are generated within the account settings, granting programmatic access. These keys are crucial for authenticating requests and are associated with specific permissions configured by the user. Kraken's API is designed for reliability and provides comprehensive documentation for developers looking to integrate programmatic trading strategies or access real-time market information.

To summarize the initial setup:

1. Account Creation & Verification: Register and complete identity checks.
2. API Key Generation: Create and configure API keys with specific permissions.
3. First Request: Use the generated keys to make an authenticated API call.

The following table provides a quick reference for the initial steps:

Create an account and get keys

Before interacting with the Kraken API, establishing a user account is mandatory. This process begins by navigating to the Kraken sign-up page and providing an email address, a unique username, and a strong password. Following email confirmation, users proceed to identity verification, a critical step for compliance with Anti-Money Laundering (AML) and Know Your Customer (KYC) regulations, which are standard practices in the cryptocurrency exchange industry, as detailed by regulatory bodies like the Financial Crimes Enforcement Network (FinCEN) in the United States. Kraken offers different verification levels (Starter, Intermediate, Pro), each unlocking progressively higher deposit and withdrawal limits and access to advanced features. For API access beyond public market data, completing at least the Starter verification is typically required.

Once identity verification is complete, API keys can be generated. These keys are fundamental for authenticating programmatic requests to the Kraken API. To generate them, log into your Kraken account and navigate to the API key management section, usually found under 'Settings' or 'Security'. When creating a new key pair, you will be prompted to define its permissions. Granular control over permissions is available, allowing you to restrict API access to specific actions such as reading market data, managing orders, or accessing account balances. It is a security best practice to grant only the minimum necessary permissions for each API key. Upon creation, Kraken will display your API Key and Secret Key. The Secret Key is shown only once and should be stored securely, as it cannot be retrieved later. Both the API Key (public) and Secret Key (private) are essential for signing requests.

Your first request

Making your first authenticated request to the Kraken API involves a few steps: choosing an endpoint, constructing the request, and signing it with your API keys. For this example, we will use the /0/private/Balance endpoint to retrieve your account balances, which requires authentication. This is a common first step to confirm API key functionality.

Kraken's private API endpoints require requests to be signed using an HMAC-SHA512 signature. The signature is generated using your Private Key and includes a nonce (a unique, incrementing number) to prevent replay attacks. The request body, nonce, and endpoint path are all part of the signature generation process. Detailed instructions for Kraken REST API authentication are available in the official documentation.

Here's a conceptual outline for a Python example using the requests library and hashlib for signing:

import hashlib
import hmac
import base64
import time
import requests

# Replace with your actual API Key and Secret Key
API_KEY = "YOUR_API_KEY"
API_SECRET = "YOUR_SECRET_KEY"

API_URL = "https://api.kraken.com"

def get_kraken_signature(urlpath, data, secret):
    """Sign a request for the Kraken API."""
    postdata = urlpath + hashlib.sha256(data.encode('utf8')).digest().decode('latin1')
    encoded = base64.b64decode(secret)
    signature = hmac.new(encoded, postdata.encode('utf8'), hashlib.sha512)
    return base64.b64encode(signature.digest()).decode('utf8')

def kraken_request(url_path, data, api_key, api_secret):
    nonce = str(int(1000 * time.time()))
    data["nonce"] = nonce
    headers = {
        "API-Key": api_key,
        "API-Sign": get_kraken_signature(url_path, '&'.join([f"{k}={v}" for k, v in data.items()]), api_secret)
    }
    response = requests.post(API_URL + url_path, headers=headers, data=data)
    return response.json()

# Example: Get account balance
url_path = "/0/private/Balance"
data = {}

try:
    response_data = kraken_request(url_path, data, API_KEY, API_SECRET)
    print("Kraken Balance Response:")
    print(response_data)
except requests.exceptions.RequestException as e:
    print(f"Request failed: {e}")
except Exception as e:
    print(f"An error occurred: {e}")

This Python snippet demonstrates how to construct a signed request for a private endpoint. It generates a nonce, creates a POST data string, and then uses the API Secret to generate the HMAC-SHA512 signature. This signature, along with the API Key, is sent in the request headers. The /0/private/Balance endpoint will return a JSON object containing your current asset balances if the request is correctly signed and authenticated.

Common next steps

After successfully making your first authenticated API call to Kraken, several common next steps can enhance your integration:

• Explore Public Endpoints: Begin by fetching public market data, such as current prices, order books, and trade history, using endpoints like /0/public/Ticker or /0/public/OHLC. These do not require authentication and can help you understand data structures before moving to complex trading logic. The Kraken REST API documentation provides a full list of available endpoints.
• Implement Order Management: Progress to creating, querying, and canceling orders. This involves endpoints like /0/private/AddOrder and /0/private/CancelOrder. Ensure your API keys have the necessary 'Trade' permissions.
• Integrate WebSocket API: For real-time market data and private user data updates (e.g., balance changes, order statuses), integrate the Kraken WebSocket API. This provides a persistent connection, reducing latency compared to repeated REST calls.
• Error Handling: Implement robust error handling in your code. The Kraken API returns specific error codes and messages, which are crucial for diagnosing issues and ensuring the stability of your application.
• Security Best Practices: Review and implement advanced security measures, such as IP whitelisting for your API keys and regularly rotating your keys. Consider using a dedicated API key for each application or purpose to minimize potential impact in case of a compromise.
• Utilize SDKs: While direct HTTP requests are feasible, using one of the Kraken API client libraries (SDKs) for Python, Node.js, Java, Go, or C# can simplify development by abstracting away the complexities of request signing and data parsing.
• Test with Testnet: If available, utilize a testnet environment to test your trading strategies and API integrations without risking real funds. This is a common practice for financial APIs, including those in traditional finance, as highlighted by resources on OAuth 2.0 best practices for secure application development.

Troubleshooting the first call

Encountering issues during your first API call is common. Here are some troubleshooting steps and common pitfalls:

• Incorrect API Key/Secret: Double-check that you are using the correct API Key and Secret Key. Remember that the Secret Key is only shown once upon generation. If lost, you must generate a new key pair.
• Invalid Signature: This is a frequent issue. The signature generation process is sensitive to every component: the nonce, the request path, and the POST data. Ensure the POST data string used for signing exactly matches the data sent in the request body. Verify the encoding (UTF-8) and base64 decoding steps. The Kraken authentication guide provides precise details on signature calculation.
• Nonce Issues: The nonce must be an ever-increasing, unique integer for each request. If you send a nonce that is equal to or less than a previously used nonce, the API will reject your request. Ensure your nonce generation mechanism is robust, typically using a timestamp.
• Permissions: For private endpoints like /0/private/Balance, ensure your API key has the necessary 'Account Balance' or 'Query Funds' permission. If you try to place an order without 'Trade' permission, it will fail.
• Time Synchronization: Your system's time must be closely synchronized with Kraken's servers. A significant time difference can cause authentication failures. Use Network Time Protocol (NTP) to keep your system clock accurate.
• URL Path Mismatch: Ensure the urlpath used in the signature generation matches the actual path segment of the API endpoint you are calling (e.g., /0/private/Balance, not https://api.kraken.com/0/private/Balance).
• Endpoint Availability: Verify that the endpoint you are calling is correct and exists in the Kraken REST API reference.
• Network Issues: Check your internet connection and ensure no firewalls or proxies are blocking access to api.kraken.com.
• Kraken API Status: Check the Kraken Status Page for any ongoing API issues or maintenance.