# npm
npm install @axionquant/sdk

# yarn
yarn add @axionquant/sdk

# pnpm
pnpm add @axionquant/sdk

import { Axion } from '@axionquant/sdk';

const client = new Axion('your_api_key_here');

// Get ESG data for Apple
const esgData = await client.esg.data('AAPL');
console.log(esgData);

// Get stock prices for Microsoft
const prices = await client.stocks.prices('MSFT', {
  from: '2024-01-01',
  to: '2024-03-01'
});
console.log(prices);

// Get economic indicators
const gdp = await client.econ.dataset('GDP_USA');

// Get company news
const news = await client.news.company('AAPL');

// Get ETF holdings
const holdings = await client.etfs.holdings('SPY');

import { Axion } from '@axionquant/sdk';
import type { ApiResponse } from '@axionquant/sdk';

const client = new Axion('your_api_key_here');

async function fetchFinancialData() {
  try {
    const esgData: ApiResponse = await client.esg.data('AAPL');
    const stockPrices: ApiResponse = await client.stocks.prices('MSFT');
    return { esgData, stockPrices };
  } catch (error) {
    console.error('Error:', error);
    throw error;
  }
}

// Company profile
const profile = await client.profiles.profile('AAPL');
console.log(`Company: ${profile.name}`);

// Recommendation trends
const recommendations = await client.profiles.recommendation('AAPL');
console.log(`Strong Buy: ${recommendations.strongBuy}`);

// Key statistics
const stats = await client.profiles.statistics('AAPL');
console.log(`Market Cap: ${stats.marketCap}`);

// Calendar events
const calendar = await client.profiles.calendar('AAPL');
console.log(`Next Earnings: ${calendar.earnings[0].date}`);

// Revenue data for last 4 quarters
const revenue = await client.financials.revenue('AAPL', { periods: 4 });
console.log('Quarterly Revenue:', revenue);

// Key financial metrics
const metrics = await client.financials.metrics('AAPL');
console.log(`P/E Ratio: ${metrics.pe_ratio}`);
console.log(`ROE: ${metrics.return_on_equity}`);

// Complete financial snapshot
const snapshot = await client.financials.snapshot('AAPL');
console.log(snapshot);

// DCF analysis
const dcfValue = await client.financials.dcfValue('AAPL');
console.log(`Fair Price: ${dcfValue.fairPrice}, Recommendation: ${dcfValue.recommendation}`);

const dcfRate = await client.financials.dcfRate('AAPL');
console.log(`WACC: ${(dcfRate.wacc * 100).toFixed(2)}%`);

// Financial statements
const balanceSheet = await client.financials.balanceSheet('AAPL');
const income = await client.financials.incomeStatement('AAPL');
const cashflow = await client.financials.cashFlowStatement('AAPL');

// Earnings history
const history = await client.earnings.history('MSFT');
console.log(`EPS Q1: ${history[0].eps}`);

// Specific quarter report
const report = await client.earnings.report('MSFT', {
  year: '2024',
  quarter: 'Q1'
});
console.log(`Revenue: ${report.revenue}`);
console.log(`EPS: ${report.eps}`);

// Earnings call transcript
const transcript = await client.earnings.transcript('MSFT', {
  year: '2024',
  quarter: 'Q1'
});
console.log(`Transcript: ${transcript.text.substring(0, 200)}...`);

// Transcript sentiment
const sentiment = await client.earnings.transcriptSentiment('transcript_id');
console.log(`Sentiment: ${sentiment.score}`);

// Get recent 10-K filings
const filings = await client.filings.recent('AAPL', { 
  form: '10-K', 
  limit: 3 
});

// Search for Q1 2024 filings
const searchResults = await client.filings.search({
  ticker: 'AAPL',
  year: '2024',
  quarter: 'Q1'
});

// Get all 10-Q filings for Q1 2024
const forms = await client.filings.history('AAPL', '10-Q', {
  startDate: '2024-01-01',
  endDate: '2024-03-31'
});

// Get raw document text and sentiment
const text = await client.filings.documentText('document_id_here');
const sentiment = await client.filings.documentSentiment('document_id_here');
console.log(`Sentiment: ${sentiment.score}`);

// Institutional ownership
const institutions = await client.insiders.institutions('AAPL');
console.log(`Top Holder: ${institutions[0].name} (${institutions[0].shares} shares)`);

// Recent insider transactions
const transactions = await client.insiders.transactions('AAPL');
transactions.slice(0,5).forEach(t => {
  console.log(`${t.insider}: ${t.shares} shares ${t.type}`);
});

// Ownership breakdown
const ownership = await client.insiders.ownership('AAPL');
console.log(`Insider Ownership: ${ownership.insider_percent}%`);

// Get web traffic for Amazon
const traffic = await client.webTraffic.traffic('AMZN');
console.log(`Monthly Visits: ${traffic.monthly_visits}`);
console.log(`YoY Growth: ${traffic.yoy_growth}%`);

// All US ETFs
const usEtfs = await client.etfs.tickers({ country: 'US' });

// SPY quote
const spyQuote = await client.etfs.ticker('SPY');
console.log(`SPY: $${spyQuote.price}`);

// Fund details and holdings
const spyFund = await client.etfs.fund('SPY');
const spyHoldings = await client.etfs.holdings('SPY');
const spyAllHoldings = await client.etfs.holdingsAll('SPY');

// Historical prices
const spyPrices = await client.etfs.prices('SPY', {
  from: '2024-01-01',
  to: '2024-03-31'
});

// All US tickers
const usStocks = await client.stocks.tickers({ country: 'US' });

// Apple quote
const appleQuote = await client.stocks.ticker('AAPL');
console.log(`Price: ${appleQuote.price}`);

// Historical weekly prices for Microsoft
const msftPrices = await client.stocks.prices('MSFT', {
  from: '2024-01-01',
  to: '2024-03-31',
  frame: 'weekly'
});

// Top gainers this week
const gainers = await client.stocks.gainers({ days: 7, limit: 10 });

// List available sectors
const sectors = await client.stocks.list('sector');

// All cryptocurrencies
const allCrypto = await client.crypto.tickers();

// Bitcoin quote
const btc = await client.crypto.ticker('BTC-USD');
console.log(`Bitcoin: $${btc.price}`);

// Ethereum historical daily prices
const ethPrices = await client.crypto.prices('ETH-USD', {
  from: '2024-01-01',
  to: '2024-03-31',
  frame: 'daily'
});

// Top crypto gainers
const topGainers = await client.crypto.gainers({ days: 1, limit: 5 });

// AI-powered FRED series search
const series = await client.econ.find('US GDP quarterly');

// Search for inflation series
const inflationSeries = await client.econ.search('inflation');

// Get GDP dataset
const gdpData = await client.econ.dataset('GDP_USA');

// Important US economic events this month
const calendar = await client.econ.calendar({
  from: '2024-04-01',
  to: '2024-04-30',
  country: 'US',
  minImportance: 3
});

// All EUR forex pairs
const eurPairs = await client.forex.tickers({ country: 'EUR' });

// EUR/USD quote
const eurusd = await client.forex.ticker('EUR-USD');
console.log(`EUR/USD: ${eurusd.price}`);

// Historical prices
const eurGbpPrices = await client.forex.prices('EUR-GBP', {
  from: '2024-01-01',
  to: '2024-03-31',
  frame: 'daily'
});

// Crude oil futures quote
const crudeOil = await client.futures.ticker('CL');
console.log(`Crude Oil: $${crudeOil.price}`);

// Historical gold futures prices
const goldPrices = await client.futures.prices('GC', {
  from: '2024-01-01',
  to: '2024-03-31',
  frame: 'daily'
});

// S&P 500 quote
const spx = await client.indices.ticker('SPX');
console.log(`S&P 500: ${spx.price}`);

// Dow Jones components
const dowComponents = await client.indices.components('DJI');
console.log(`Components: ${dowComponents.length}`);

// Which indices hold AAPL
const aaplExposure = await client.indices.exposure('AAPL');
console.log(`Found in ${aaplExposure.indices.length} indices`);

// General market news
const marketNews = await client.news.general();
console.log(`Latest: ${marketNews.articles[0].headline}`);

// News for Apple
const aaplNews = await client.news.company('AAPL');

// News by country
const ukNews = await client.news.country('GB');

try {
  const data = await client.esg.data('INVALID');
} catch (error) {
  if (error.message.includes('404')) {
    console.log('Ticker not found');
  } else if (error.message.includes('429')) {
    // Rate limit - exponential backoff
    await delay(1000);
    return fetchWithRetry();
  } else if (error.message.includes('Authentication')) {
    console.error('API key missing - provide one to the client');
  } else if (error.message.includes('Connection')) {
    console.error('Network error - check your connection');
  }
  throw error;
}

import { Axion } from '@axionquant/sdk';
import type { ApiResponse } from '@axionquant/sdk';
import SEOMetadata from '@/components/SEOMetadata';

interface CustomESG {
  score: number;
  grade: string;
  environmental: number;
}

class Analyst {
  client = new Axion(process.env.API_KEY!);

  async getESG(ticker: string): Promise<CustomESG> {
    const data = await this.client.esg.data(ticker);
    return {
      score: data.score,
      grade: data.grade,
      environmental: data.environmental_score
    };
  }
}

# Install via pip
pip install axionquant-sdk

# Or clone from GitHub
git clone https://github.com/axionquant/python-sdk.git
cd python-sdk
pip install -e .

from axion import Axion

# Initialize client
client = Axion(api_key="your_api_key_here")

# Get stock data
quote = client.stocks.quote("AAPL")
print(f"Apple price: {quote['price']}")

# Get ESG data
esg = client.esg.data("AAPL")
print(f"ESG Score: {esg['score']}")

# Get company profile
profile = client.profiles.info("AAPL")
print(f"Company: {profile['name']}")

from axion import Axion

# Recommended: set API key once
client = Axion(api_key="your_api_key_here")

# All API categories are now available
credit = client.credit.search("Apple")
esg = client.esg.data("AAPL")
stocks = client.stocks.quote("AAPL")
crypto = client.crypto.quote("BTC-USD")

# Get all US stock tickers
us_stocks = client.stocks.tickers(country="US")

# Get quote for a single stock
aapl = client.stocks.quote("AAPL")
print(f"Apple: {aapl['price']} ({aapl['change']}%)")

# Get historical prices with date range
prices = client.stocks.prices(
    "MSFT",
    from_date="2024-01-01",
    to_date="2024-03-31",
    frame="weekly"
)

# Convert to pandas DataFrame
import pandas as pd
df = pd.DataFrame(prices)
df['date'] = pd.to_datetime(df['date'])
print(df.head())

# Get all crypto tickers
all_crypto = client.crypto.tickers()

# Filter by type (e.g., "coin", "token")
stablecoins = client.crypto.tickers(type="stablecoin")

# Get Bitcoin quote
btc = client.crypto.quote("BTC-USD")
print(f"Bitcoin: {btc['price']:,.2f}")

# Get Ethereum historical prices
eth_prices = client.crypto.prices(
    "ETH-USD",
    from_date="2024-01-01",
    to_date="2024-03-31",
    frame="daily"
)

# Get company profile
profile = client.profiles.profile("AAPL")
print(f"Company: {profile['name']}")
print(f"Industry: {profile['industry']}")
print(f"Sector: {profile['sector']}")

# Get key statistics
stats = client.profiles.statistics("AAPL")
print(f"Market Cap: {stats['market_cap']:,.0f}")
print(f"P/E Ratio: {stats['pe_ratio']}")

# Get upcoming events
calendar = client.profiles.calendar("AAPL")
for event in calendar:
    print(f"{event['date']}: {event['event_type']}")

# Get revenue history (last 4 quarters)
revenue = client.financials.revenue("AAPL", periods=4)
for period in revenue:
    print(f"{period['date']}: {period['value']:,.0f}")

# Get comprehensive financial snapshot
snapshot = client.financials.snapshot("AAPL")
print(f"Revenue (TTM): {snapshot['revenue_ttm']:,.0f}")
print(f"Gross Margin: {snapshot['gross_margin']}%")
print(f"Operating Margin: {snapshot['operating_margin']}%")
print(f"Debt/Equity: {snapshot['debt_to_equity']}")

# Calculate free cash flow trend
fcf = client.financials.free_cash_flow("AAPL", periods=5)
fcf_values = [period['value'] for period in fcf]
print(f"FCF Trend: {fcf_values}")

# DCF valuation
dcf = client.financials.dcf_value("AAPL")
print(f"Fair Price: {dcf['fair_price']:.2f}, Recommendation: {dcf['recommendation']}")

# Discount rate / WACC
rate = client.financials.dcf_rate("AAPL")
print(f"WACC: {rate['wacc'] * 100:.2f}%")

# List all available form types
form_types = client.filings.list_forms()
print(form_types[:5])

# Get recent 10-K filings for Apple
filings = client.filings.recent("AAPL", form="10-K", limit=5)
for filing in filings:
    print(f"{filing['filed_date']}: {filing['form']}")

# Search for Q1 2024 filings
q1_filings = client.filings.search(
    form="10-Q",
    year="2024",
    quarter="Q1"
)

# Get specific 10-Q filing in Q1 2024
ten_q = client.filings.history(
    "AAPL",
    form_type="10-Q",
    start_date="2024-01-01",
    end_date="2024-03-31"
)

# Get institutional ownership
institutions = client.insiders.institutions("AAPL")
print("Top Institutional Holders:")
for holder in institutions[:5]:
    print(f"{holder['name']}: {holder['shares']:,} shares")

# Get insider transactions
transactions = client.insiders.transactions("AAPL")
print("
Recent Insider Transactions:")
for tx in transactions[:5]:
    print(f"{tx['date']}: {tx['insider']} - {tx['transaction_type']}: {tx['shares']:,} shares")

# Get ownership breakdown
ownership = client.insiders.ownership("AAPL")
print(f"
Insiders: {ownership['insider_percent']}%")
print(f"Institutions: {ownership['institution_percent']}%")
print(f"Retail: {ownership['retail_percent']}%")

# Get earnings history
history = client.earnings.history("AAPL")
print("Earnings History:")
for period in history:
    print(f"{period['date']}: EPS {period['eps']} vs {period['estimate']} est")

# Get earnings trend
trend = client.earnings.trend("AAPL")
print(f"
Current Quarter Estimate: {trend['current_quarter_estimate']}")
print(f"Next Quarter Estimate: {trend['next_quarter_estimate']}")
print(f"Current Year Estimate: {trend['current_year_estimate']}")

# Get specific quarterly report
q1_2024 = client.earnings.report("AAPL", year="2024", quarter="Q1")
print(f"
Q1 2024 Revenue: {q1_2024['revenue']:,.0f}")
print(f"Q1 2024 EPS: {q1_2024['eps']}")

# Search for inflation series
inflation_series = client.econ.search("inflation")
for series in inflation_series:
    print(f"{series['id']}: {series['name']}")

# Get GDP data
gdp = client.econ.dataset("GDP_USA")
print("
GDP History:")
for observation in gdp['observations'][-5:]:
    print(f"{observation['date']}: {observation['value']}")

# Get important economic events
calendar = client.econ.calendar(
    from_date="2024-04-01",
    to_date="2024-04-30",
    country="US",
    min_importance=3
)
for event in calendar:
    print(f"{event['date']}: {event['event']} - {event['importance']}/3")

# Get overall sentiment
sentiment = client.sentiment.all("TSLA")
print(f"Overall Score: {sentiment['overall_score']}")
print(f"Sentiment: {sentiment['sentiment']}")

# Get social media sentiment
social = client.sentiment.social("TSLA")
print(f"
Social Media:")
print(f"Mentions: {social['mentions']}")
print(f"Positive: {social['positive_percent']}%")
print(f"Negative: {social['negative_percent']}%")

# Get analyst sentiment
analyst = client.sentiment.analyst("TSLA")
print(f"
Analyst Sentiment:")
print(f"Buy: {analyst['buy_count']}")
print(f"Hold: {analyst['hold_count']}")
print(f"Sell: {analyst['sell_count']}")

# Get top general headlines
headlines = client.news.general()
print("Top Financial News:")
for article in headlines[:5]:
    print(f"- {article['title']} ({article['source']})")

# Get company-specific news
aapl_news = client.news.company("AAPL")
print("
Apple News:")
for article in aapl_news[:3]:
    print(f"{article['published_at']}: {article['title']}")

# Get news by category
earnings_news = client.news.category("earnings")
mergers_news = client.news.category("mergers")

# Get Apple's suppliers
suppliers = client.supply_chain.suppliers("AAPL")
print("Apple Suppliers:")
for supplier in suppliers[:5]:
    print(f"- {supplier['name']} ({supplier['ticker']})")

# Get industry peers
peers = client.supply_chain.peers("AAPL")
print("
Industry Peers:")
for peer in peers:
    print(f"- {peer['name']} ({peer['ticker']})")

# Get major customers
customers = client.supply_chain.customers("TSLA")
print("
Tesla Customers:")
for customer in customers:
    print(f"- {customer['name']}")

# Get SPY fund information
spy = client.etfs.fund("SPY")
print(f"SPY - {spy['name']}")
print(f"AUM: {spy['aum']:,.0f}")
print(f"Expense Ratio: {spy['expense_ratio']}%")
print(f"Inception Date: {spy['inception_date']}")

# Get top holdings
holdings = client.etfs.holdings("SPY")
print("
Top Holdings:")
for holding in holdings[:5]:
    print(f"{holding['name']}: {holding['weight']}%")

# Get sector exposure
exposure = client.etfs.exposure("SPY")
print("
Sector Exposure:")
for sector, weight in exposure['sectors'].items():
    print(f"{sector}: {weight}%")

# Get all major forex pairs
pairs = client.forex.tickers()
print("Major Forex Pairs:")
for pair in pairs[:5]:
    print(f"- {pair['symbol']}: {pair['name']}")

# Get EUR/USD quote
eur_usd = client.forex.quote("EUR-USD")
print(f"
EUR/USD: {eur_usd['price']}")
print(f"Change: {eur_usd['change']}%")
print(f"Day Range: {eur_usd['day_low']} - {eur_usd['day_high']}")

# Get historical USD/JPY prices
usd_jpy = client.forex.prices(
    "USD-JPY",
    from_date="2024-01-01",
    to_date="2024-03-31",
    frame="daily"
)

# Get all futures tickers
futures = client.futures.tickers()
print("Available Futures:")
for future in futures[:5]:
    print(f"- {future['symbol']}: {future['name']}")

# Get gold futures quote
gold = client.futures.quote("GC=F")
print(f"
Gold Futures: {gold['price']}")
print(f"Settlement: {gold['settlement']}")
print(f"Open Interest: {gold['open_interest']}")

# Get crude oil futures prices
oil_prices = client.futures.prices(
    "CL=F",
    from_date="2024-01-01",
    to_date="2024-03-31",
    frame="daily"
)

# Get all indices
indices = client.indices.tickers()
print("Major Indices:")
for index in indices[:5]:
    print(f"- {index['symbol']}: {index['name']}")

# Get S&P 500 quote
spx = client.indices.quote("^GSPC")
print(f"
S&P 500: {spx['price']:,.2f}")
print(f"Change: {spx['change']}%")
print(f"YTD Change: {spx['ytd_change']}%")

# Get NASDAQ historical prices
nasdaq = client.indices.prices(
    "^IXIC",
    from_date="2024-01-01",
    to_date="2024-03-31",
    frame="daily"
)