Other Examples

Option Pricing Tools

The C++ SDK does not include an option-pricing library. Use its market data methods to retrieve option bid and ask prices, implied volatility, Greeks, and other inputs, then perform local calculations with a third-party library such as QuantLib.

The following example demonstrates how to retrieve option market data using the C++ SDK and analyze the returned Greeks and implied volatility.

⚠️
Note
For local option pricing and Greeks calculations, using the QuantLib C++ library is recommended. The local calculation portions in the examples below require QuantLib to be installed separately.

Get Option Quotes and Greeks via SDK

Use get_option_brief to get a real-time option quote snapshot. The returned data includes implied volatility and Greeks.

#include <iostream>
#include "tigerapi/quote_client.h"
#include "tigerapi/client_config.h"

using namespace TIGER_API;
using namespace web::json;

int main() {
    // Initialize configuration
    ClientConfig config(false, U("your_config_directory_path"));

    // Initialize quote client
    QuoteClient quote_client(config);

    // Get option quote snapshot (including Greeks)
    // Option identifier format: "Underlying  ExpiryDirectionStrike" (OCC format)
    value result = quote_client.get_option_brief(U("AAPL  240621C00190000"));
    ucout << result.serialize() << std::endl;

    return 0;
}

Response provenance

get_option_brief returns unmodeled web::json::value. The SDK repository has no verified fixture for this example, so no synthetic Greeks or prices are shown.

Get Option Chain Data

Use get_option_chain to get the complete option chain for a given underlying and expiration date, with optional filter conditions.

⚠️
Option-chain Greeks are deprecated
Greek-related option-chain request flags, filters/models, and response fields delta, gamma, theta, vega, and rho are Deprecated. Their values are updated daily and are not timely enough for intraday use. Do not use them for real-time trading decisions. Use Option Pricing Tools with current market inputs instead.

#include <iostream>
#include "tigerapi/quote_client.h"
#include "tigerapi/client_config.h"

using namespace TIGER_API;
using namespace web::json;

int main() {
    ClientConfig config(false, U("your_config_directory_path"));
    QuoteClient quote_client(config);

    // Get option expiration dates
    value symbols = value::array();
    symbols[0] = value::string(U("AAPL"));
    value expirations = quote_client.get_option_expiration(symbols);
    ucout << U("Expirations: ") << expirations.serialize() << std::endl;

    // Get option chain for a specific expiration date
    value chain = quote_client.get_option_chain(U("AAPL"), U("2024-06-21"));
    ucout << U("Option chain: ") << chain.serialize() << std::endl;

    // Get option chain with filter (in-the-money only)
    value filter = value::object();
    filter[U("in_the_money")] = value::boolean(true);
    value filtered_chain = quote_client.get_option_chain(U("AAPL"), U("2024-06-21"), filter);
    ucout << U("In-the-money options: ") << filtered_chain.serialize() << std::endl;

    return 0;
}

Local Option Pricing with QuantLib

If you need to perform local option pricing and Greeks calculations, you can use the QuantLib C++ library. The following example demonstrates calculating implied volatility and Greeks for American options using QuantLib.

info
QuantLib C++ library must be installed first. Install via vcpkg: vcpkg install quantlib, or via brew: brew install quantlib

#include <iostream>
#include <ql/quantlib.hpp>

using namespace QuantLib;

int main() {
    // Set evaluation date
    Date evaluationDate(19, April, 2022);
    Settings::instance().evaluationDate() = evaluationDate;

    // Option parameters
    Option::Type optionType = Option::Call;
    Real underlying = 985.0;       // Underlying asset price
    Real strike = 990.0;           // Strike price
    Rate riskFreeRate = 0.017;     // Risk-free rate
    Rate dividendRate = 0.0;       // Dividend rate
    Date settlementDate(14, April, 2022);   // Settlement date
    Date expirationDate(22, April, 2022);   // Option expiration date

    // Build exercise and underlying
    auto exercise = ext::make_shared<AmericanExercise>(settlementDate, expirationDate);
    auto payoff = ext::make_shared<PlainVanillaPayoff>(optionType, strike);
    VanillaOption option(payoff, exercise);

    // Market data handles
    auto spotHandle = ext::make_shared<SimpleQuote>(underlying);
    auto volHandle = ext::make_shared<SimpleQuote>(0.0); // Temporarily set to 0
    auto rateHandle = ext::make_shared<SimpleQuote>(riskFreeRate);
    auto divHandle = ext::make_shared<SimpleQuote>(dividendRate);

    DayCounter dayCounter = Actual365Fixed();
    Calendar calendar = UnitedStates(UnitedStates::NYSE);

    auto flatVol = ext::make_shared<BlackConstantVol>(
        evaluationDate, calendar,
        Handle<Quote>(volHandle), dayCounter);
    auto flatRate = ext::make_shared<FlatForward>(
        evaluationDate, Handle<Quote>(rateHandle), dayCounter);
    auto flatDiv = ext::make_shared<FlatForward>(
        evaluationDate, Handle<Quote>(divHandle), dayCounter);

    auto bsmProcess = ext::make_shared<BlackScholesMertonProcess>(
        Handle<Quote>(spotHandle),
        Handle<YieldTermStructure>(flatDiv),
        Handle<YieldTermStructure>(flatRate),
        Handle<BlackVolTermStructure>(flatVol));

    // Use finite difference pricing engine
    option.setPricingEngine(
        ext::make_shared<FdBlackScholesVanillaEngine>(bsmProcess, 100, 100));

    // Calculate implied volatility from option price
    Real optionPrice = 33.6148; // Option market price, can use (ask + bid) / 2
    Volatility impliedVol = option.impliedVolatility(optionPrice, bsmProcess);
    std::cout << "implied volatility: " << impliedVol << std::endl;

    // Update volatility and recalculate Greeks
    volHandle->setValue(impliedVol);

    std::cout << "value: " << option.NPV() << std::endl;
    std::cout << "delta: " << option.delta() << std::endl;
    std::cout << "gamma: " << option.gamma() << std::endl;
    std::cout << "theta: " << option.theta() << std::endl;
    std::cout << "vega: " << option.vega() << std::endl;
    std::cout << "rho: " << option.rho() << std::endl;

    std::cout << std::endl;

    // Calculate option price directly using known implied volatility
    Real knownVolatility = 0.6153;
    volHandle->setValue(knownVolatility);

    std::cout << "---- Calculate using known implied volatility ----" << std::endl;
    std::cout << "value: " << option.NPV() << std::endl;
    std::cout << "delta: " << option.delta() << std::endl;
    std::cout << "gamma: " << option.gamma() << std::endl;
    std::cout << "theta: " << option.theta() << std::endl;
    std::cout << "vega: " << option.vega() << std::endl;
    std::cout << "rho: " << option.rho() << std::endl;

    return 0;
}

Full Example: SDK Market Data + QuantLib Calculation

The following example combines Tiger Open API market data queries with QuantLib local calculations to implement a complete option analysis workflow.

#include <iostream>
#include <string>
#include "tigerapi/quote_client.h"
#include "tigerapi/client_config.h"
#include <ql/quantlib.hpp>

using namespace TIGER_API;
using namespace web::json;
using namespace QuantLib;

int main() {
    // 1. Get option market data via SDK
    ClientConfig config(false, U("your_config_directory_path"));
    QuoteClient quote_client(config);

    // Get real-time option quotes
    value brief = quote_client.get_option_brief(U("AAPL  240209P00185000"));
    ucout << U("Option brief: ") << brief.serialize() << std::endl;

    // Get underlying stock latest price
    value symbols = value::array();
    symbols[0] = value::string(U("AAPL"));
    value stock_brief = quote_client.get_brief(symbols);
    ucout << U("Stock brief: ") << stock_brief.serialize() << std::endl;

    // 2. Extract key parameters from returned data
    // Note: In actual code, you need to parse fields based on the returned JSON structure
    double askPrice = 2.50;   // From brief
    double bidPrice = 2.30;   // From brief
    double latestPrice = 185.0; // From stock_brief

    // 3. Perform local calculation using QuantLib
    Date evaluationDate(5, February, 2024);
    Settings::instance().evaluationDate() = evaluationDate;

    Option::Type optionType = Option::Put;
    Real underlying = latestPrice;
    Real strike = 185.0;
    Rate riskFreeRate = 0.0241;
    Rate dividendRate = 0.0;
    Date settlementDate(5, February, 2024);
    Date expirationDate(9, February, 2024);

    auto exercise = ext::make_shared<AmericanExercise>(settlementDate, expirationDate);
    auto payoff = ext::make_shared<PlainVanillaPayoff>(optionType, strike);
    VanillaOption option(payoff, exercise);

    auto spotHandle = ext::make_shared<SimpleQuote>(underlying);
    auto volHandle = ext::make_shared<SimpleQuote>(0.0);
    auto rateHandle = ext::make_shared<SimpleQuote>(riskFreeRate);
    auto divHandle = ext::make_shared<SimpleQuote>(dividendRate);

    DayCounter dayCounter = Actual365Fixed();
    Calendar calendar = UnitedStates(UnitedStates::NYSE);

    auto flatVol = ext::make_shared<BlackConstantVol>(
        evaluationDate, calendar,
        Handle<Quote>(volHandle), dayCounter);
    auto flatRate = ext::make_shared<FlatForward>(
        evaluationDate, Handle<Quote>(rateHandle), dayCounter);
    auto flatDiv = ext::make_shared<FlatForward>(
        evaluationDate, Handle<Quote>(divHandle), dayCounter);

    auto bsmProcess = ext::make_shared<BlackScholesMertonProcess>(
        Handle<Quote>(spotHandle),
        Handle<YieldTermStructure>(flatDiv),
        Handle<YieldTermStructure>(flatRate),
        Handle<BlackVolTermStructure>(flatVol));

    option.setPricingEngine(
        ext::make_shared<FdBlackScholesVanillaEngine>(bsmProcess, 100, 100));

    // Calculate implied volatility (using average of ask and bid)
    Real optionPrice = (askPrice + bidPrice) / 2.0;
    Volatility impliedVol = option.impliedVolatility(optionPrice, bsmProcess);
    volHandle->setValue(impliedVol);

    std::cout << "---- Option Analysis Results ----" << std::endl;
    std::cout << "implied volatility: " << impliedVol << std::endl;
    std::cout << "value: " << option.NPV() << std::endl;
    std::cout << "delta: " << option.delta() << std::endl;
    std::cout << "gamma: " << option.gamma() << std::endl;
    std::cout << "theta: " << option.theta() << std::endl;
    std::cout << "vega: " << option.vega() << std::endl;
    std::cout << "rho: " << option.rho() << std::endl;

    return 0;
}

Output provenance

This example prints QuantLib calculations directly with std::cout and does not produce JSON. Values depend on inputs, QuantLib version, and pricing engine, so no fixed synthetic output is shown.

In addition to the examples provided in this documentation, more C++ SDK examples are being continuously updated. New examples will be synchronized to the GitHub repository.

https://github.com/tigerfintech/openapi-cpp-sdk

We will continue to add examples to the documentation and GitHub repository. If you have questions about using the SDK, use the documentation site's Ask AI feature or Contact Us.