Perspicium Public API v0

Perspicium's API unlocks the same options analytics, greeks, and quant dashboards that power the web app so you can embed them in trading tools, research notebooks, and portfolio workflows.

At a glance

What it does: real-time options intelligence (expected moves, IV surfaces, OI, UOA, GEX) and higher-level quant analytics (risk, correlation, optimizer, market memory, seasonality).
Who it's for: discretionary and systematic traders, brokerage/product teams, research groups, and quant devs who need normalized analytics without operating an options data pipeline.
Data sources: options chains from CBOE, equities/ETFs from Tiingo, macro series from FRED, and crypto support via KuCoin spot feeds.
Freshness & latency: options chains refresh intraday (sub-minute); equities update nightly after Tiingo settles; macro series refresh on release; median API latency is < 500 ms from the us-east PoP.

Quickstart

# 1. Grab your API key in https://perspicium.com (Account → API)
# 2. Test connectivity
curl -H "Authorization: ApiKey YOUR_KEY" \
  "https://perspicium.com/api/v0/ping"

# 3. First real call: expected move for SPY
curl -H "Authorization: ApiKey YOUR_KEY" \
  "https://perspicium.com/api/v0/options/expected-move?ticker=SPY"

Tip: store YOUR_KEY in an environment variable (e.g., PERSPI_API_KEY) before scripting.

Authentication & secure usage

API keys are 48-character hexadecimal strings tied 1:1 to your Perspicium account. Do not embed them in client apps; keep them server-side or in a secrets manager.

For v0, send the key in a header on every request. Accepted forms:

Authorization: ApiKey <token> (preferred)
Authorization: Bearer <token> (legacy clients)
X-API-Key: <token>

Error handling:

Missing key → 401 with {"error":"missing_api_key"}
Invalid key → 401 with {"error":"invalid_api_key"}

Rotate compromised keys in Account → API.

Rate limits

Limits are enforced per API key. Default: 10 requests per day and 100 requests per month.

Scope	Limit
Blueprint default	10 / day, 100 / month
/api/v0/ping	60 / minute
Options + Greeks	30 / minute

Endpoints

GET /api/v0/ping

Sanity check that your key works.

curl -H "Authorization: ApiKey YOUR_KEY" \
  "https://perspicium.com/api/v0/ping"

import requests

url = "https://perspicium.com/api/v0/ping"
params = {
}
headers = {"Authorization": "ApiKey YOUR_KEY"}

response = requests.get(url, params=params, headers=headers)
print(response.json())

const url = new URL("https://perspicium.com/api/v0/ping");
const params = {

};
Object.keys(params).forEach(key => url.searchParams.append(key, params[key]));

const headers = { "Authorization": "ApiKey YOUR_KEY" };

fetch(url, { headers })
  .then(response => response.json())
  .then(data => console.log(data));

const axios = require('axios');

axios.get('https://perspicium.com/api/v0/ping', {
  params: {
  },
  headers: {
    Authorization: 'ApiKey YOUR_KEY'
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.log(error);
});

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	url := "https://perspicium.com/api/v0/ping"
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "ApiKey YOUR_KEY")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}

Options

GET /api/v0/options/expected-move

Get expected move bands derived from straddle prices.

Param	Required	Description
`ticker`	No	Underlying symbol (e.g. SPY)
`range_pct`	No	Strike range %

curl -H "Authorization: ApiKey YOUR_KEY" \
  "https://perspicium.com/api/v0/options/expected-move?ticker=SPY&range_pct=1.0"

import requests

url = "https://perspicium.com/api/v0/options/expected-move"
params = {
    "ticker": "SPY",
    "range_pct": "1.0",
}
headers = {"Authorization": "ApiKey YOUR_KEY"}

response = requests.get(url, params=params, headers=headers)
print(response.json())

const url = new URL("https://perspicium.com/api/v0/options/expected-move");
const params = {
  "ticker": "SPY",
  "range_pct": "1.0",

};
Object.keys(params).forEach(key => url.searchParams.append(key, params[key]));

const headers = { "Authorization": "ApiKey YOUR_KEY" };

fetch(url, { headers })
  .then(response => response.json())
  .then(data => console.log(data));

const axios = require('axios');

axios.get('https://perspicium.com/api/v0/options/expected-move', {
  params: {
    ticker: 'SPY',
    range_pct: '1.0',
  },
  headers: {
    Authorization: 'ApiKey YOUR_KEY'
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.log(error);
});

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	url := "https://perspicium.com/api/v0/options/expected-move?ticker=SPY&range_pct=1.0"
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "ApiKey YOUR_KEY")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}

GET /api/v0/options/iv

Get IV smile and term structure.

Param	Required	Description
`ticker`	No	Underlying symbol
`range_pct`	No	Smile width

curl -H "Authorization: ApiKey YOUR_KEY" \
  "https://perspicium.com/api/v0/options/iv?ticker=SPX&range_pct=0.15"

import requests

url = "https://perspicium.com/api/v0/options/iv"
params = {
    "ticker": "SPX",
    "range_pct": "0.15",
}
headers = {"Authorization": "ApiKey YOUR_KEY"}

response = requests.get(url, params=params, headers=headers)
print(response.json())

const url = new URL("https://perspicium.com/api/v0/options/iv");
const params = {
  "ticker": "SPX",
  "range_pct": "0.15",

};
Object.keys(params).forEach(key => url.searchParams.append(key, params[key]));

const headers = { "Authorization": "ApiKey YOUR_KEY" };

fetch(url, { headers })
  .then(response => response.json())
  .then(data => console.log(data));

const axios = require('axios');

axios.get('https://perspicium.com/api/v0/options/iv', {
  params: {
    ticker: 'SPX',
    range_pct: '0.15',
  },
  headers: {
    Authorization: 'ApiKey YOUR_KEY'
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.log(error);
});

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	url := "https://perspicium.com/api/v0/options/iv?ticker=SPX&range_pct=0.15"
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "ApiKey YOUR_KEY")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}

GET /api/v0/options/open-interest

Get aggregated open interest or volume by strike.

Param	Required	Description
`ticker`	No	Underlying symbol
`range_pct`	No	Strike window to pull
`basis`	No	open_interest or volume
`expiration`	No	Expiration filter (repeat param for multiples)

curl -H "Authorization: ApiKey YOUR_KEY" \
  "https://perspicium.com/api/v0/options/open-interest?ticker=QQQ&range_pct=0.25&basis=volume&expiration=2024-06-21"

import requests

url = "https://perspicium.com/api/v0/options/open-interest"
params = {
    "ticker": "QQQ",
    "range_pct": "0.25",
    "basis": "volume",
    "expiration": "2024-06-21",
}
headers = {"Authorization": "ApiKey YOUR_KEY"}

response = requests.get(url, params=params, headers=headers)
print(response.json())

const url = new URL("https://perspicium.com/api/v0/options/open-interest");
const params = {
  "ticker": "QQQ",
  "range_pct": "0.25",
  "basis": "volume",
  "expiration": "2024-06-21",

};
Object.keys(params).forEach(key => url.searchParams.append(key, params[key]));

const headers = { "Authorization": "ApiKey YOUR_KEY" };

fetch(url, { headers })
  .then(response => response.json())
  .then(data => console.log(data));

const axios = require('axios');

axios.get('https://perspicium.com/api/v0/options/open-interest', {
  params: {
    ticker: 'QQQ',
    range_pct: '0.25',
    basis: 'volume',
    expiration: '2024-06-21',
  },
  headers: {
    Authorization: 'ApiKey YOUR_KEY'
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.log(error);
});

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	url := "https://perspicium.com/api/v0/options/open-interest?ticker=QQQ&range_pct=0.25&basis=volume&expiration=2024-06-21"
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "ApiKey YOUR_KEY")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}

GET /api/v0/options/uoa

Get unusual options activity alerts.

Param	Required	Description
`ticker`	No	Underlying symbol

curl -H "Authorization: ApiKey YOUR_KEY" \
  "https://perspicium.com/api/v0/options/uoa?ticker=TSLA"

import requests

url = "https://perspicium.com/api/v0/options/uoa"
params = {
    "ticker": "TSLA",
}
headers = {"Authorization": "ApiKey YOUR_KEY"}

response = requests.get(url, params=params, headers=headers)
print(response.json())

const url = new URL("https://perspicium.com/api/v0/options/uoa");
const params = {
  "ticker": "TSLA",

};
Object.keys(params).forEach(key => url.searchParams.append(key, params[key]));

const headers = { "Authorization": "ApiKey YOUR_KEY" };

fetch(url, { headers })
  .then(response => response.json())
  .then(data => console.log(data));

const axios = require('axios');

axios.get('https://perspicium.com/api/v0/options/uoa', {
  params: {
    ticker: 'TSLA',
  },
  headers: {
    Authorization: 'ApiKey YOUR_KEY'
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.log(error);
});

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	url := "https://perspicium.com/api/v0/options/uoa?ticker=TSLA"
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "ApiKey YOUR_KEY")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}

GET /api/v0/options/chain

Get raw options chain data.

Param	Required	Description
`ticker`	No	Underlying symbol
`range_pct`	No	Strike window to include
`expiry`	No	Specific expiration date

curl -H "Authorization: ApiKey YOUR_KEY" \
  "https://perspicium.com/api/v0/options/chain?ticker=SPY&range_pct=0.15&expiry=2024-06-21"

import requests

url = "https://perspicium.com/api/v0/options/chain"
params = {
    "ticker": "SPY",
    "range_pct": "0.15",
    "expiry": "2024-06-21",
}
headers = {"Authorization": "ApiKey YOUR_KEY"}

response = requests.get(url, params=params, headers=headers)
print(response.json())

const url = new URL("https://perspicium.com/api/v0/options/chain");
const params = {
  "ticker": "SPY",
  "range_pct": "0.15",
  "expiry": "2024-06-21",

};
Object.keys(params).forEach(key => url.searchParams.append(key, params[key]));

const headers = { "Authorization": "ApiKey YOUR_KEY" };

fetch(url, { headers })
  .then(response => response.json())
  .then(data => console.log(data));

const axios = require('axios');

axios.get('https://perspicium.com/api/v0/options/chain', {
  params: {
    ticker: 'SPY',
    range_pct: '0.15',
    expiry: '2024-06-21',
  },
  headers: {
    Authorization: 'ApiKey YOUR_KEY'
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.log(error);
});

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	url := "https://perspicium.com/api/v0/options/chain?ticker=SPY&range_pct=0.15&expiry=2024-06-21"
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "ApiKey YOUR_KEY")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}

Greeks

GET /api/v0/greeks/gex

Get Gamma Exposure (GEX) profile.

Param	Required	Description
`ticker`	No	Underlying symbol
`basis`	No	open_interest or volume
`range_pct`	No	Strike window to aggregate
`expiration`	No	Expiration filter (repeat param for multiples)

curl -H "Authorization: ApiKey YOUR_KEY" \
  "https://perspicium.com/api/v0/greeks/gex?ticker=SPY&basis=open_interest&range_pct=0.05&expiration=2024-06-21"

import requests

url = "https://perspicium.com/api/v0/greeks/gex"
params = {
    "ticker": "SPY",
    "basis": "open_interest",
    "range_pct": "0.05",
    "expiration": "2024-06-21",
}
headers = {"Authorization": "ApiKey YOUR_KEY"}

response = requests.get(url, params=params, headers=headers)
print(response.json())

const url = new URL("https://perspicium.com/api/v0/greeks/gex");
const params = {
  "ticker": "SPY",
  "basis": "open_interest",
  "range_pct": "0.05",
  "expiration": "2024-06-21",

};
Object.keys(params).forEach(key => url.searchParams.append(key, params[key]));

const headers = { "Authorization": "ApiKey YOUR_KEY" };

fetch(url, { headers })
  .then(response => response.json())
  .then(data => console.log(data));

const axios = require('axios');

axios.get('https://perspicium.com/api/v0/greeks/gex', {
  params: {
    ticker: 'SPY',
    basis: 'open_interest',
    range_pct: '0.05',
    expiration: '2024-06-21',
  },
  headers: {
    Authorization: 'ApiKey YOUR_KEY'
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.log(error);
});

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	url := "https://perspicium.com/api/v0/greeks/gex?ticker=SPY&basis=open_interest&range_pct=0.05&expiration=2024-06-21"
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "ApiKey YOUR_KEY")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}

Quant

GET /api/v0/quant/risk

Get risk metrics (Sharpe, Beta, Drawdown) vs benchmark.

Param	Required	Description
`ticker`	No	Asset symbol
`benchmark`	No	Benchmark symbol
`period`	No	Lookback period
`window`	No	Rolling window (days)

curl -H "Authorization: ApiKey YOUR_KEY" \
  "https://perspicium.com/api/v0/quant/risk?ticker=NVDA&benchmark=SPY&period=5y&window=60"

import requests

url = "https://perspicium.com/api/v0/quant/risk"
params = {
    "ticker": "NVDA",
    "benchmark": "SPY",
    "period": "5y",
    "window": "60",
}
headers = {"Authorization": "ApiKey YOUR_KEY"}

response = requests.get(url, params=params, headers=headers)
print(response.json())

const url = new URL("https://perspicium.com/api/v0/quant/risk");
const params = {
  "ticker": "NVDA",
  "benchmark": "SPY",
  "period": "5y",
  "window": "60",

};
Object.keys(params).forEach(key => url.searchParams.append(key, params[key]));

const headers = { "Authorization": "ApiKey YOUR_KEY" };

fetch(url, { headers })
  .then(response => response.json())
  .then(data => console.log(data));

const axios = require('axios');

axios.get('https://perspicium.com/api/v0/quant/risk', {
  params: {
    ticker: 'NVDA',
    benchmark: 'SPY',
    period: '5y',
    window: '60',
  },
  headers: {
    Authorization: 'ApiKey YOUR_KEY'
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.log(error);
});

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	url := "https://perspicium.com/api/v0/quant/risk?ticker=NVDA&benchmark=SPY&period=5y&window=60"
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "ApiKey YOUR_KEY")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}

GET /api/v0/quant/asset-correlation

Get correlation matrix for standard asset basket.

Param	Required	Description
`period`	No	Lookback period
`window`	No	Rolling window (days)

curl -H "Authorization: ApiKey YOUR_KEY" \
  "https://perspicium.com/api/v0/quant/asset-correlation?period=3y&window=90"

import requests

url = "https://perspicium.com/api/v0/quant/asset-correlation"
params = {
    "period": "3y",
    "window": "90",
}
headers = {"Authorization": "ApiKey YOUR_KEY"}

response = requests.get(url, params=params, headers=headers)
print(response.json())

const url = new URL("https://perspicium.com/api/v0/quant/asset-correlation");
const params = {
  "period": "3y",
  "window": "90",

};
Object.keys(params).forEach(key => url.searchParams.append(key, params[key]));

const headers = { "Authorization": "ApiKey YOUR_KEY" };

fetch(url, { headers })
  .then(response => response.json())
  .then(data => console.log(data));

const axios = require('axios');

axios.get('https://perspicium.com/api/v0/quant/asset-correlation', {
  params: {
    period: '3y',
    window: '90',
  },
  headers: {
    Authorization: 'ApiKey YOUR_KEY'
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.log(error);
});

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	url := "https://perspicium.com/api/v0/quant/asset-correlation?period=3y&window=90"
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "ApiKey YOUR_KEY")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}

GET /api/v0/quant/market-memory

Find historical price patterns similar to recent price action.

Param	Required	Description
`ticker`	No	Asset symbol
`kernel_size`	No	Pattern length (days)
`similarity`	No	Similarity metric (cosine, euclidean)
`top_n`	No	How many matches to return
`min_separation`	No	Minimum days between matches

curl -H "Authorization: ApiKey YOUR_KEY" \
  "https://perspicium.com/api/v0/quant/market-memory?ticker=SPY&kernel_size=30&similarity=cosine&top_n=5&min_separation=10"

import requests

url = "https://perspicium.com/api/v0/quant/market-memory"
params = {
    "ticker": "SPY",
    "kernel_size": "30",
    "similarity": "cosine",
    "top_n": "5",
    "min_separation": "10",
}
headers = {"Authorization": "ApiKey YOUR_KEY"}

response = requests.get(url, params=params, headers=headers)
print(response.json())

const url = new URL("https://perspicium.com/api/v0/quant/market-memory");
const params = {
  "ticker": "SPY",
  "kernel_size": "30",
  "similarity": "cosine",
  "top_n": "5",
  "min_separation": "10",

};
Object.keys(params).forEach(key => url.searchParams.append(key, params[key]));

const headers = { "Authorization": "ApiKey YOUR_KEY" };

fetch(url, { headers })
  .then(response => response.json())
  .then(data => console.log(data));

const axios = require('axios');

axios.get('https://perspicium.com/api/v0/quant/market-memory', {
  params: {
    ticker: 'SPY',
    kernel_size: '30',
    similarity: 'cosine',
    top_n: '5',
    min_separation: '10',
  },
  headers: {
    Authorization: 'ApiKey YOUR_KEY'
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.log(error);
});

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	url := "https://perspicium.com/api/v0/quant/market-memory?ticker=SPY&kernel_size=30&similarity=cosine&top_n=5&min_separation=10"
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "ApiKey YOUR_KEY")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}

GET /api/v0/quant/portfolio-optimizer

Optimize portfolio weights for given objective.

Param	Required	Description
`tickers`	Yes	List of tickers (repeat param)
`objective`	No	sharpe, min_var, equal_weight
`period`	No	Lookback period

curl -H "Authorization: ApiKey YOUR_KEY" \
  "https://perspicium.com/api/v0/quant/portfolio-optimizer?tickers=AAPL&objective=sharpe&period=5y"

import requests

url = "https://perspicium.com/api/v0/quant/portfolio-optimizer"
params = {
    "tickers": "AAPL",
    "objective": "sharpe",
    "period": "5y",
}
headers = {"Authorization": "ApiKey YOUR_KEY"}

response = requests.get(url, params=params, headers=headers)
print(response.json())

const url = new URL("https://perspicium.com/api/v0/quant/portfolio-optimizer");
const params = {
  "tickers": "AAPL",
  "objective": "sharpe",
  "period": "5y",

};
Object.keys(params).forEach(key => url.searchParams.append(key, params[key]));

const headers = { "Authorization": "ApiKey YOUR_KEY" };

fetch(url, { headers })
  .then(response => response.json())
  .then(data => console.log(data));

const axios = require('axios');

axios.get('https://perspicium.com/api/v0/quant/portfolio-optimizer', {
  params: {
    tickers: 'AAPL',
    objective: 'sharpe',
    period: '5y',
  },
  headers: {
    Authorization: 'ApiKey YOUR_KEY'
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.log(error);
});

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	url := "https://perspicium.com/api/v0/quant/portfolio-optimizer?tickers=AAPL&objective=sharpe&period=5y"
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "ApiKey YOUR_KEY")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}

GET /api/v0/quant/seasonality

Get seasonality statistics and pivots.

Param	Required	Description
`ticker`	No	Asset symbol
`grouping`	No	monthly, quarterly, weekday
`period`	No	Lookback period

curl -H "Authorization: ApiKey YOUR_KEY" \
  "https://perspicium.com/api/v0/quant/seasonality?ticker=SPY&grouping=monthly&period=10y"

import requests

url = "https://perspicium.com/api/v0/quant/seasonality"
params = {
    "ticker": "SPY",
    "grouping": "monthly",
    "period": "10y",
}
headers = {"Authorization": "ApiKey YOUR_KEY"}

response = requests.get(url, params=params, headers=headers)
print(response.json())

const url = new URL("https://perspicium.com/api/v0/quant/seasonality");
const params = {
  "ticker": "SPY",
  "grouping": "monthly",
  "period": "10y",

};
Object.keys(params).forEach(key => url.searchParams.append(key, params[key]));

const headers = { "Authorization": "ApiKey YOUR_KEY" };

fetch(url, { headers })
  .then(response => response.json())
  .then(data => console.log(data));

const axios = require('axios');

axios.get('https://perspicium.com/api/v0/quant/seasonality', {
  params: {
    ticker: 'SPY',
    grouping: 'monthly',
    period: '10y',
  },
  headers: {
    Authorization: 'ApiKey YOUR_KEY'
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.log(error);
});

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	url := "https://perspicium.com/api/v0/quant/seasonality?ticker=SPY&grouping=monthly&period=10y"
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "ApiKey YOUR_KEY")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}

GET /api/v0/quant/sector-insights

Get sector performance and breadth metrics.

Param	Required	Description
`period`	No	Lookback period

curl -H "Authorization: ApiKey YOUR_KEY" \
  "https://perspicium.com/api/v0/quant/sector-insights?period=1M"

import requests

url = "https://perspicium.com/api/v0/quant/sector-insights"
params = {
    "period": "1M",
}
headers = {"Authorization": "ApiKey YOUR_KEY"}

response = requests.get(url, params=params, headers=headers)
print(response.json())

const url = new URL("https://perspicium.com/api/v0/quant/sector-insights");
const params = {
  "period": "1M",

};
Object.keys(params).forEach(key => url.searchParams.append(key, params[key]));

const headers = { "Authorization": "ApiKey YOUR_KEY" };

fetch(url, { headers })
  .then(response => response.json())
  .then(data => console.log(data));

const axios = require('axios');

axios.get('https://perspicium.com/api/v0/quant/sector-insights', {
  params: {
    period: '1M',
  },
  headers: {
    Authorization: 'ApiKey YOUR_KEY'
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.log(error);
});

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	url := "https://perspicium.com/api/v0/quant/sector-insights?period=1M"
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "ApiKey YOUR_KEY")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}

Menu

Navigation

Options

Options Greeks

Quantitative Tools

Macroeconomics

Perspicium Public API v0

At a glance

Quickstart

Authentication & secure usage

Rate limits

Endpoints

GET /api/v0/ping

Options

GET /api/v0/options/expected-move

GET /api/v0/options/iv

GET /api/v0/options/open-interest

GET /api/v0/options/uoa

GET /api/v0/options/chain

Greeks

GET /api/v0/greeks/gex

Quant

GET /api/v0/quant/risk

GET /api/v0/quant/asset-correlation

GET /api/v0/quant/market-memory

GET /api/v0/quant/portfolio-optimizer

GET /api/v0/quant/seasonality

GET /api/v0/quant/sector-insights