justETF APIjustetf.com ↗
Access justETF data via API: search thousands of ETFs, retrieve profiles with TER and fund size, and pull full monthly performance history by ISIN.
What is the justETF API?
The justETF API exposes 4 endpoints covering ETF search, detailed profiles, monthly performance history, and cost-based screening. The search_etfs endpoint returns paginated results with key metrics — TER, fund size, distribution policy, replication method, and YTD return — filterable by asset class and fund currency. Each endpoint is keyed by ISIN, the standard identifier for ETFs listed across European and global exchanges.
curl -X GET 'https://api.parse.bot/scraper/80344a09-fa70-4748-8f48-f70c29c84c59/search_etfs?query=S%26P+500&start=0&length=5&asset_class=class-equity&fund_currency=USD' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace justetf-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""justETF SDK walkthrough — search, profile, and performance data."""
from parse_apis.justetf_api import JustETF, ETFNotFound
client = JustETF()
# Search for S&P 500 ETFs, capped at 3 results
for etf in client.etfs.search(query="S&P 500", asset_class="class-equity", limit=3):
print(etf.name, etf.ter, etf.fund_currency, etf.fund_size)
# Drill into one ETF by ISIN
detail = client.etfs.get(isin="IE00B5BMR087")
print(detail.name, detail.ter, detail.replication_method, detail.distribution_policy)
# Get monthly performance for that ETF
report = detail.performance()
for month in report.monthly_returns[:6]:
print(month.year, month.month, month.return_pct)
# Low-cost EUR equity filter
for etf in client.etfs.filter_low_cost_eur(limit=3):
print(etf.name, etf.ter, etf.fund_currency)
# Typed error handling for a non-existent ISIN
try:
client.etfs.get(isin="XX000000000X")
except ETFNotFound as exc:
print(f"ETF not found: {exc.isin}")
print("exercised: etfs.search / etfs.get / etf.performance / etfs.filter_low_cost_eur")Full-text search over justETF's ETF database. Matches ISIN, WKN, ticker, or name against the query. Results are sorted by fund size descending. Supports offset-based pagination via start/length. Filters narrow results by asset class or fund currency. Returns total count and a page of ETF summaries.
| Param | Type | Description |
|---|---|---|
| query | string | Search query term (ISIN, WKN, ticker, or name) |
| start | integer | Pagination offset (0-based index of first result) |
| length | integer | Number of results per page (max 100) |
| asset_class | string | Filter by asset class. Confirmed values: 'class-equity', 'class-bonds'. Additional values may be accepted by the site. |
| fund_currency | string | Filter by fund currency ISO code (e.g. 'EUR', 'USD', 'GBP', 'CHF') |
{
"type": "object",
"fields": {
"items": "array of ETF summary objects with isin, name, ter, fund_currency, fund_size, ticker, wkn, distribution_policy, replication_method, inception_date, ytd_return, sustainable",
"total": "integer total number of matching ETFs"
},
"sample": {
"data": {
"items": [
{
"ter": "0.07%",
"wkn": "A0YEDG",
"isin": "IE00B5BMR087",
"name": "iShares Core S&P 500 UCITS ETF USD (Acc)",
"ticker": "SXR8",
"fund_size": "127,028",
"ytd_return": "9.32%",
"sustainable": "No",
"fund_currency": "USD",
"inception_date": "19.05.10",
"replication_method": "Full replication",
"distribution_policy": "Accumulating"
}
],
"total": 3442
},
"status": "success"
}
}About the justETF API
Search and Filter ETFs
The search_etfs endpoint accepts a free-text query (ISIN, WKN, ticker, or fund name) alongside optional filters for asset_class (e.g. class-equity, class-bonds) and fund_currency (e.g. EUR, USD). Results are paginated via start and length parameters and sorted by fund size descending. Each item in the response includes isin, name, ter, fund_currency, fund_size, ticker, wkn, distribution_policy, and replication_method.
ETF Profile Data
get_etf_profile takes a 12-character isin and returns the full metadata record for that fund: ter, wkn, isin, name, ticker, fund_size, ytd_return, sustainable (Yes/No), fund_currency, and inception_date formatted as DD.MM.YY. This is useful for building fund comparison tables or populating detail pages without additional transformation.
Monthly Performance History
get_monthly_performance returns the complete monthly return history for a given ISIN as an array of objects, each carrying year, month (Jan–Dec label), and return_pct (numeric percentage). Coverage extends from the fund's inception date to the most recent month available, making it suitable for generating heatmap visualisations or running time-series analysis.
Equity Screening by Cost
specialized_equity_filter provides a pre-configured screen for equity ETFs with a maximum TER threshold, returning results sorted by fund size with a count field and the same summary object structure as search_etfs. Use the limit parameter to control result volume. This endpoint is particularly useful for building low-cost equity fund screeners.
The justETF API is a managed, monitored endpoint for justetf.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when justetf.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official justetf.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a fund comparison table using TER, fund size, and YTD return from
search_etfs - Generate a monthly performance heatmap for any ETF using
get_monthly_performancereturn data - Screen for low-cost equity ETFs denominated in EUR using
specialized_equity_filter - Populate ETF detail pages with inception date, replication method, and sustainability flag from
get_etf_profile - Track distribution policy (accumulating vs distributing) across a watchlist of ISINs
- Filter bond ETFs by fund currency to identify USD-denominated fixed-income options via
search_etfs - Backtest or analyse annual return patterns using the full historical monthly return series per ISIN
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does justETF have an official developer API?+
What identifiers can I use to look up an ETF?+
search_etfs accepts a query parameter that matches against ISIN, WKN, ticker symbol, or fund name. For get_etf_profile and get_monthly_performance, you must supply the 12-character ISIN directly — for example, IE00B5BMR087. WKN and ticker resolution is only available through the search endpoint.Does the API return historical NAV prices or daily price series?+
get_monthly_performance and summary metrics like YTD return and fund size, but does not expose daily or historical NAV price series. You can fork this API on Parse and revise it to add an endpoint targeting daily price data.How does pagination work in `search_etfs`?+
start offset (0-based) and a length parameter for page size. The response also includes a total integer indicating the full count of matching ETFs, so you can calculate how many pages exist and iterate accordingly.