Portfolio Optimizer Getting Started: First API Request (2026)

Getting started overview

This guide outlines the process for new users to quickly begin interacting with the Portfolio Optimizer API. It covers account creation, obtaining API credentials, and executing a foundational API request. The primary goal is to enable you to make your first successful call to a Portfolio Optimizer endpoint, confirming your setup and access.

Portfolio Optimizer provides programmatic access to a suite of financial tools designed for quantitative analysis. These tools include capabilities for optimizing portfolio allocations, conducting historical backtests, and performing various risk assessments. The API is structured to support developers and researchers in integrating advanced financial models into their applications or analytical workflows.

The core workflow involves:

1. Account Creation: Registering for a Portfolio Optimizer account.
2. API Key Retrieval: Locating your unique API key within your account dashboard.
3. Environment Setup: Preparing your development environment, typically involving a programming language like Python or R.
4. First API Call: Constructing and sending an authenticated request to a basic endpoint, such as retrieving available assets or performing a simple optimization.

A successful initial call confirms that your API key is valid and that your network configuration allows communication with the Portfolio Optimizer services. This foundational step is critical before moving to more complex portfolio management tasks.

Create an account and get keys

Access to the Portfolio Optimizer API requires an active account and an associated API key. Follow these steps to set up your account and retrieve your credentials:

1. Navigate to the Signup Page: Visit the official Portfolio Optimizer pricing page.
2. Choose a Plan: Select the "Developer Plan" to start. This plan offers up to 1,000 API calls per month free of charge, which is sufficient for initial testing and development. If you require more extensive usage, you can upgrade to a paid plan later, such as the "Startup Plan" starting at €50/month for 10,000 API calls.
3. Complete Registration: Provide the required information, including your email address and a password. You may need to verify your email address to activate your account.
4. Log In: Once registered and verified, log in to your Portfolio Optimizer account dashboard.
5. Locate API Key: Within your account dashboard, navigate to the "API Keys" or "Settings" section. Your unique API key will be displayed there. This key is a long alphanumeric string that authenticates your requests. It is crucial to keep this key confidential to prevent unauthorized access to your account and usage.

The API key is typically passed in the Authorization header of your HTTP requests, often prefixed with Bearer. For example, Authorization: Bearer YOUR_API_KEY. Refer to the Portfolio Optimizer API documentation for specific authentication methods and header requirements.

Your first request

After obtaining your API key, you can make your first API call. This example uses Python, a common language for financial analysis and integration, to request a simple portfolio optimization. We will use the requests library for HTTP communication.

Prerequisites:

• Python installed (version 3.6 or higher recommended).
• The requests library installed: pip install requests.
• Your Portfolio Optimizer API key.

Example: Minimum Variance Portfolio Optimization

This example demonstrates how to find the weights of a minimum variance portfolio given a set of asset returns. This is a fundamental operation in quantitative finance, aiming to minimize portfolio risk for a given expected return.

import requests
import json

# Replace with your actual API key
API_KEY = "YOUR_PORTFOLIO_OPTIMIZER_API_KEY"
BASE_URL = "https://api.portfoliooptimizer.io/v1"

# Define the endpoint for minimum variance optimization
ENDPOINT = f"{BASE_URL}/portfolios/optimization/minimum-variance"

# Example asset data (expected returns and covariance matrix)
# In a real scenario, you would fetch this data from a financial data provider.
# For this example, we use hypothetical values.

# Expected returns for assets A, B, C
expected_returns = [
    0.05,  # Asset A
    0.08,  # Asset B
    0.12   # Asset C
]

# Covariance matrix for assets A, B, C
# Row 1: Cov(A,A), Cov(A,B), Cov(A,C)
# Row 2: Cov(B,A), Cov(B,B), Cov(B,C)
# Row 3: Cov(C,A), Cov(C,B), Cov(C,C)
covariance_matrix = [
    [0.010, 0.004, 0.002],
    [0.004, 0.015, 0.006],
    [0.002, 0.006, 0.020]
]

# Construct the request payload
payload = {
    "expectedReturns": expected_returns,
    "covarianceMatrix": covariance_matrix
}

# Set the headers, including the API key for authentication
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_KEY}"
}

print("Sending request to Portfolio Optimizer...")
try:
    response = requests.post(ENDPOINT, headers=headers, data=json.dumps(payload))
    response.raise_for_status()  # Raise an HTTPError for bad responses (4xx or 5xx)

    # Parse the JSON response
    result = response.json()

    print("Request successful! Optimization results:")
    print(json.dumps(result, indent=2))

    # Example of accessing specific results
    if "weights" in result:
        print("\nOptimal Weights:")
        for i, weight in enumerate(result["weights"]):
            print(f"  Asset {chr(65+i)}: {weight:.4f}")
    if "expectedPortfolioReturn" in result:
        print(f"Expected Portfolio Return: {result["expectedPortfolioReturn"]:.4f}")
    if "portfolioVariance" in result:
        print(f"Portfolio Variance: {result["portfolioVariance"]:.4f}")

except requests.exceptions.HTTPError as http_err:
    print(f"HTTP error occurred: {http_err}")
    print(f"Response body: {response.text}")
except requests.exceptions.ConnectionError as conn_err:
    print(f"Connection error occurred: {conn_err}")
except requests.exceptions.Timeout as timeout_err:
    print(f"Timeout error occurred: {timeout_err}")
except requests.exceptions.RequestException as req_err:
    print(f"An unexpected error occurred: {req_err}")
except json.JSONDecodeError:
    print(f"Failed to decode JSON response. Raw response: {response.text}")

This script first defines your API key and the base URL. It then constructs a JSON payload containing hypothetical expected returns and a covariance matrix for three assets. This data is essential for any portfolio optimization task, as it describes the risk-return characteristics of the assets. The requests.post call sends this data to the minimum variance optimization endpoint, including your API key in the authorization header. A successful response will contain the optimal weights for each asset, along with the expected portfolio return and variance, forming the basis of a risk-efficient portfolio. For a deeper understanding of the underlying financial mathematics, resources like Google Developers' explanation of covariance matrices can be helpful.

Common next steps

After successfully making your first API call, consider these next steps to further integrate Portfolio Optimizer into your workflow:

1. Explore Other Endpoints: Review the Portfolio Optimizer API documentation to discover other available endpoints. These include various optimization models (e.g., maximum Sharpe ratio, maximum diversification), backtesting functionalities, and risk analysis tools. Each endpoint serves a distinct purpose in quantitative portfolio management.
2. Integrate Real Data: Replace the hypothetical asset data in your scripts with real-world financial data. This typically involves connecting to financial data providers (e.g., historical stock prices, market indices, economic indicators) to obtain accurate expected returns and covariance matrices. Services like Nasdaq Data Link (formerly Quandl) or Alpaca Markets can provide historical market data necessary for realistic portfolio construction and backtesting.
3. Implement Error Handling: Enhance your code with robust error handling to manage API rate limits, invalid inputs, network issues, and other potential problems. The Python example above includes basic error handling, but production-grade applications require more comprehensive strategies, such as retry mechanisms with exponential backoff.
4. Build a Backtesting Workflow: Utilize the Backtesting API to evaluate the historical performance of your optimized portfolios or trading strategies. This involves simulating how a portfolio would have performed in the past under different market conditions, providing insights into its potential effectiveness.
5. Automate Workflows: Consider automating your portfolio optimization and rebalancing processes. This could involve scheduling API calls to run periodically, adjusting portfolio weights based on new market data or investment objectives.
6. Explore SDKs (if available): While Portfolio Optimizer does not currently list official SDKs, community-developed libraries might exist, or you can build your own wrapper around the API for easier interaction, abstracting away direct HTTP requests.

Troubleshooting the first call

If your first API call does not return the expected results, consider the following troubleshooting steps:

• Check API Key: Ensure your API key is correctly copied and included in the Authorization header with the Bearer prefix. A common mistake is a typo in the key or an incorrect header format. Verify that there are no leading or trailing spaces.
• Verify Endpoint URL: Double-check that the API endpoint URL is accurate. Refer to the Portfolio Optimizer API documentation for the exact endpoint path. Slight variations in path or versioning can lead to 404 Not Found errors.
• Review Request Payload: Confirm that your JSON payload matches the expected schema for the specific endpoint. Incorrect data types, missing required fields, or malformed JSON can result in 400 Bad Request errors. The documentation specifies the required parameters and their formats.
• Inspect HTTP Status Codes: The HTTP status code returned in the response provides crucial information. Common issues include:
  • 401 Unauthorized: Incorrect or missing API key.
  • 403 Forbidden: Your account may not have permission for the requested endpoint, or your API key might be revoked.
  • 404 Not Found: Incorrect endpoint URL.
  • 429 Too Many Requests: You have exceeded your plan's rate limit. Wait before making further requests or consider upgrading your plan.
  • 5xx Server Error: An issue on the Portfolio Optimizer server side. While rare, these typically require waiting for the service to recover.
• Examine Response Body: If an error occurs, the API often returns a JSON response containing an error message and details. Parse this response to understand the specific problem. For example, a 400 Bad Request might include validation errors for your input data.
• Check Network Connectivity: Ensure your development environment has an active internet connection and is not blocked by a firewall or proxy from accessing https://api.portfoliooptimizer.io.
• Consult Documentation and Support: If issues persist, refer to the Portfolio Optimizer documentation for more detailed troubleshooting guides or contact their support team for assistance.