Fundamental Data: Stocks, ETFs, Mutual Funds, Indices

Available with: All-In-One and Fundamentals Data Feed packages.
Consumption: Each request consumes 10 API calls.

Simple access to fundamental data API for stocks, ETFs, Mutual Funds, and Indices from different exchanges and countries. Almost all major US, UK, EU, India, and Asia exchanges.

Register & Get Data

Quick Start

To get a fundamental data feed, use the following URL:

URL
cURL
PHP
Python
R
https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json
(Sign up for free to get an API token) 
curl --location "https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json"
(Sign up for free to get an API token) 
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'GET',
));

$data = curl_exec($curl);
curl_close($curl);

try {
    $data = json_decode($data, true, 512, JSON_THROW_ON_ERROR);
    var_dump($data);
} catch (Exception $e) {
    echo 'Error. '.$e->getMessage();
}
(Sign up for free to get an API token) 
import requests

url = f'https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json'
data = requests.get(url).json()

print(data)
(Sign up for free to get an API token) 
library(httr)
library(jsonlite)

url <- 'https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json'
response <- GET(url)

if (http_type(response) == "application/json") {
    content <- content(response, "text", encoding = "UTF-8")
    cat(content)
} else {
    cat("Error while receiving data\n")
}
(Sign up for free to get an API token)
  • AAPL.US consists of two parts: {SYMBOL_NAME}.{EXCHANGE_CODE}, then you can use, for example, AAPL.MX for Mexican Stock Exchange. Or AAPL.US for NASDAQ.
  • api_token – your API KEY, which we provide after registration, to get access to bonds API you should be subscribed to the ‘Fundamentals API’ package.

For testing purposes, you can try the following API Key (works only for AAPL.US and VTI.US):

URL
cURL
PHP
Python
R
https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json
(Sign up for free to get an API token) 
curl --location "https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json"
(Sign up for free to get an API token) 
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'GET',
));

$data = curl_exec($curl);
curl_close($curl);

try {
    $data = json_decode($data, true, 512, JSON_THROW_ON_ERROR);
    var_dump($data);
} catch (Exception $e) {
    echo 'Error. '.$e->getMessage();
}
(Sign up for free to get an API token) 
import requests

url = f'https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json'
data = requests.get(url).json()

print(data)
(Sign up for free to get an API token) 
library(httr)
library(jsonlite)

url <- 'https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json'
response <- GET(url)

if (http_type(response) == "application/json") {
    content <- content(response, "text", encoding = "UTF-8")
    cat(content)
} else {
    cat("Error while receiving data\n")
}
(Sign up for free to get an API token)

Which Fundamental Data is supported by our APIs

  • Major US companies are supported from 1985, more than 30 years, and non-US symbols are supported from 2000, it’s more than 21 years of financial data. Symbols from major US exchanges (around 11000 tickers in total from NYSE, NASDAQ, and ARCA) supported for 20 years both yearly and quarterly. For minor companies, we have data for the last 6 years and the previous 20 quarters. And the data is continually growing.
  • We support more than 20.000 US Funds. Our database has equity funds as well as balanced and bond-based mutual funds.
  • We also support details for more than 10,000 ETFs from different exchanges and countries.
  • We provide Index Constituents (or Index Components) data for all major indices all around the world.
  • Please note: not all companies report the whole financial data, therefore it cannot be guaranteed that each company will have all available data points filled with data.
  • Due to a very complex data structure, we support fundamental data feeds only in JSON format.

Stocks Fundamentals Data API

For stocks we do provide the following fields:

  • Code and name of the company.
  • Address, including Web URL and Phone.
  • Company logos for major companies all around the world.
  • CIK, and Employer Identification Number
  • Fiscal Year-End and IPO Date.
  • The company is International or Domestic.
  • Exchange, currency, and country information.
  • Sector/industry and company description.
  • Home Category: Domestic or ADR.
  • IsDelisted – where the ticker had been delisted or not.
  • DelistedDate – the date of ticker delisting.
  • Listings – listings of the ticker on other exchanges.
  • Officers – list of company executives.
  • General Information:
    • Market Capitalization
    • EBITDA, PE ratio, PEG ratio.
    • Earnings per share (EPS), book value, dividend share, dividend yield.
    • Profit margin, operating margin, return on assets and return on equity.
    • Revenue, revenue per share, gross profit, diluted EPS, and quarterly earnings growth (year-over-year).
  • Numbers for Valuation
    • Trailing PE, Forward PE
    • Price/Sales
    • Price/Book Ratio
    • Enterprise Value/Revenue
    • Enterprise Value Ebitda
  • Share Statistics
    • Shares
      outstanding,
    • Shares Float,
    • Percent Held by Insiders,
    • Percent Held by Institutions,
  • Technical Indicators
    • Beta
    • 52 Week high/low
    • 50/200 day moving average
  • Splits and Dividends
    • The forward annual dividend rate and yield
    • Payout ratio.
    • Dividend date, ex-dividend date.
    • Last split factor and split date.
  • Holders. Institutions and Funds.
    • Name of the holder: the institution of the fund.
    • Total shares with percentage.
    • Date of the report and change.
  • Insider Transactions (Form 4)
    • Report Date.
    • Owner CIK, owner name, owner relationship, owner title (or officer title).
    • Transaction date, transaction amount, transaction price, transaction type.
    • Post-transaction amount.
    • SEC Link.
  • Outstanding Shares:
    • Date.
    • Amount of outstanding shares on the date in Millions.
  • Earnings:
    • History and Trend.
    • Quarterly and Annual.
  • Financial Reports. Annual and Quarterly.
    • Balance Sheet
    • Cash Flow
    • Income Statements.

You can check a full description of the Fundamental API fields in the article in our Academy.

For testing purposes you can try the following API Key (works only for AAPL.US ticker): demo:

URL
cURL
PHP
Python
R
https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json
(Sign up for free to get an API token) 
curl --location "https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json"
(Sign up for free to get an API token) 
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'GET',
));

$data = curl_exec($curl);
curl_close($curl);

try {
    $data = json_decode($data, true, 512, JSON_THROW_ON_ERROR);
    var_dump($data);
} catch (Exception $e) {
    echo 'Error. '.$e->getMessage();
}
(Sign up for free to get an API token) 
import requests

url = f'https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json'
data = requests.get(url).json()

print(data)
(Sign up for free to get an API token) 
library(httr)
library(jsonlite)

url <- 'https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json'
response <- GET(url)

if (http_type(response) == "application/json") {
    content <- content(response, "text", encoding = "UTF-8")
    cat(content)
} else {
    cat("Error while receiving data\n")
}
(Sign up for free to get an API token)

As a result, you will get the following data in JSON format only (click on the image will open a page with JSON data).

Fundamental Data Feed

Filter Fields and WEBSERVICE support

The API supports field filtering with the parameter ‘filter=’. We support multi-layer filtering. For example, if you want to get only the ‘General’ block, then you can use the following URL:

URL
cURL
PHP
Python
R
https://eodhd.com/api/fundamentals/AAPL.US?filter=General::Code&api_token=demo&fmt=json
(Sign up for free to get an API token) 
curl --location "https://eodhd.com/api/fundamentals/AAPL.US?filter=General::Code&api_token=demo&fmt=json"
(Sign up for free to get an API token) 
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://eodhd.com/api/fundamentals/AAPL.US?filter=General::Code&api_token=demo&fmt=json',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'GET',
));

$data = curl_exec($curl);
curl_close($curl);

try {
    $data = json_decode($data, true, 512, JSON_THROW_ON_ERROR);
    var_dump($data);
} catch (Exception $e) {
    echo 'Error. '.$e->getMessage();
}
(Sign up for free to get an API token) 
import requests

url = f'https://eodhd.com/api/fundamentals/AAPL.US?filter=General::Code&api_token=demo&fmt=json'
data = requests.get(url).json()

print(data)
(Sign up for free to get an API token) 
library(httr)
library(jsonlite)

url <- 'https://eodhd.com/api/fundamentals/AAPL.US?filter=General::Code&api_token=demo&fmt=json'
response <- GET(url)

if (http_type(response) == "application/json") {
    content <- content(response, "text", encoding = "UTF-8")
    cat(content)
} else {
    cat("Error while receiving data\n")
}
(Sign up for free to get an API token)

Different layers are divided with “::” and it’s possible to have any number of layers, you want, for example:

URL
cURL
PHP
Python
R
https://eodhd.com/api/fundamentals/AAPL.US?filter=Financials::Balance_Sheet::yearly&api_token=demo&fmt=json
(Sign up for free to get an API token) 
curl --location "https://eodhd.com/api/fundamentals/AAPL.US?filter=Financials::Balance_Sheet::yearly&api_token=demo&fmt=json"
(Sign up for free to get an API token) 
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://eodhd.com/api/fundamentals/AAPL.US?filter=Financials::Balance_Sheet::yearly&api_token=demo&fmt=json',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'GET',
));

$data = curl_exec($curl);
curl_close($curl);

try {
    $data = json_decode($data, true, 512, JSON_THROW_ON_ERROR);
    var_dump($data);
} catch (Exception $e) {
    echo 'Error. '.$e->getMessage();
}
(Sign up for free to get an API token) 
import requests

url = f'https://eodhd.com/api/fundamentals/AAPL.US?filter=Financials::Balance_Sheet::yearly&api_token=demo&fmt=json'
data = requests.get(url).json()

print(data)
(Sign up for free to get an API token) 
library(httr)
library(jsonlite)

url <- 'https://eodhd.com/api/fundamentals/AAPL.US?filter=Financials::Balance_Sheet::yearly&api_token=demo&fmt=json'
response <- GET(url)

if (http_type(response) == "application/json") {
    content <- content(response, "text", encoding = "UTF-8")
    cat(content)
} else {
    cat("Error while receiving data\n")
}
(Sign up for free to get an API token)

It’s also possible to use several, comma-separated, filters, for example:

URL
cURL
PHP
Python
R
https://eodhd.com/api/fundamentals/AAPL.US?filter=General::Code,General,Earnings&api_token=demo&fmt=json
(Sign up for free to get an API token) 
curl --location "https://eodhd.com/api/fundamentals/AAPL.US?filter=General::Code,General,Earnings&api_token=demo&fmt=json"
(Sign up for free to get an API token) 
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://eodhd.com/api/fundamentals/AAPL.US?filter=General::Code,General,Earnings&api_token=demo&fmt=json',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'GET',
));

$data = curl_exec($curl);
curl_close($curl);

try {
    $data = json_decode($data, true, 512, JSON_THROW_ON_ERROR);
    var_dump($data);
} catch (Exception $e) {
    echo 'Error. '.$e->getMessage();
}
(Sign up for free to get an API token) 
import requests

url = f'https://eodhd.com/api/fundamentals/AAPL.US?filter=General::Code,General,Earnings&api_token=demo&fmt=json'
data = requests.get(url).json()

print(data)
(Sign up for free to get an API token) 
library(httr)
library(jsonlite)

url <- 'https://eodhd.com/api/fundamentals/AAPL.US?filter=General::Code,General,Earnings&api_token=demo&fmt=json'
response <- GET(url)

if (http_type(response) == "application/json") {
    content <- content(response, "text", encoding = "UTF-8")
    cat(content)
} else {
    cat("Error while receiving data\n")
}
(Sign up for free to get an API token)

Equities Fundamentals Data API

We support the following data for symbols. Please note: not all companies report the whole financial data, therefore it cannot be guaranteed that each company will have all available data points filled with data.

  • General data and fundamentals highlights. Sector and industry, company description, market capitalization, EBITDA, book value, dividend share, dividend yield, earnings share, estimated EPS (earnings per share) for current and next year/next quarter, P/E (or PE or Price to Earnings) ratio.
  • Earnings.
    • History: EPS Actual, EPS Estimate, Difference, Surprise (percents)
    • Trend: Earnings Estimate, Revenue Estimate for different periods.
  • Financial Reports. We support US and non-US companies. Major US companies are supported from 1985, more than 30 years, and non-US symbols are supported from 2000, it’s more than 21 years of financial data. Symbols from major US exchanges (around 11000 tickers in total from NYSE, NASDAQ, and ARCA) supported for 20 years both yearly and quarterly. For minor companies, we have data for the last 6 years and the previous 20 quarters. And the data is continually growing.

ETFs Fundamentals Data API

We also support details for more than 10,000 ETFs from different exchanges and countries. Here you can find the ETF Information and details we support at the moment.

  • ETF general data.
    • Company Name, and URL.
    • Current Yield, Dividend Payments information.
    • Ongoing charge, Average Market Capitalization (in Millions).
    • Net expense ratio and annual holdings turnover.
    • Total Net Assets.
  • Technicals
    • Beta
    • 52-week high/lows
    • 50/200-day moving average
  • Breakdowns
    • Market Capitalization.
    • Asset Allocation.
    • World Regions.
    • Sector Weights.
    • Top 10 Holdings.
    • Valuation and Growth Rates for portfolio and compare to the ETF category.
    • Performance: Volatility, Expected Returns, Sharp Ratio, Returns YTD/3 years/5 years/10 years.

Funds Fundamentals Data API

We support more than 20.000 US Mutual Funds. Our database has equity funds as well as balanced and bond-based mutual funds. We support all major information about almost all mutual funds on the market, including:

  • General Information.
    • Fund Summary.
    • Fund Family.
    • Inception date and other data.
  • Asset Allocation.
    • Cash.
    • US Stocks.
    • Non-US stocks.
    • Bonds.
    • Other.
  • Value Growth Measures.
    • Price/Prospective Earnings.
    • Price/Book.
    • Price/Sales.
    • Price/Cash Flow.
    • and many other metrics.
  • Sector Weightings.
    • Cyclical
    • Sensitive
    • Defensive
  • World Regions (for equity and balanced funds).
    • America, Europe, Asia, and other regions.
    • Market Classification: developed and emerging markets.
  • Top Countries (for bond-based mutual funds).

It’s also possible to get data from Mutual Fund by ticker. For example, for “Schwab S&P 500 Index” both identifications are correct: SWPPX.US and US8085098551.

Here is an example of the structure for Charles Schwab fund “Schwab S&P 500 Index” provided by our fundamentals API. And do not forget that we also have End-Of-Day with our Stock Price Data API (End-Of-Day Historical Data) and Live data with our Live/Real-time Stock Prices API for SWPPX and other funds.

Register & Get Data

Schwab S&P 500 Index Example

Current and Historical Index Constituents API

  1. Current components. Through the Fundamentals API package, we provide Index Constituents (or Index Components) data for all major indices worldwide. A full list could be found here.

Available data for each Component:

  • Code
  • Exchange
  • Name
  • Sector
  • Industry

2. Historical Components. For the following indices:

  • SPSIOP (S&P)
  • SPSIRE (S&P)
  • OEX (S&P)
  • MID (S&P)
  • GSPC (S&P)
  • SML (S&P)
  • DJC (Dow Jones)
  • DJI (Dow Jones)
  • DJT (Dow Jones)
  • DJU (Dow Jones)

the response includes not only the current list of active constituents but non-active constituents (those previously included in an index) as well, along with the dates of their addition and exclusion. Non-active constituents are available under the “HistoricalTickerComponents” section of the response. Plus there is an additional data field “Weight” (based on “free float market cap” for S&P and “price-weighted” for DJ).

For more detailed data on S&P and Dow Jones indices, we offer a new standalone product available through our API Marketplace. This new product provides daily updated index components with additional parameters for over 100 indices, including the S&P 500, 600, 100, 400, Dow Jones, and more. Visit our product page to learn more.

The query example:

URL
cURL
PHP
Python
R
https://eodhd.com/api/fundamentals/GSPC.INDX?api_token={YOUR_API_TOKEN}&fmt=json
(Sign up for free to get an API token) 
curl --location "https://eodhd.com/api/fundamentals/GSPC.INDX?api_token={YOUR_API_TOKEN}&fmt=json"
(Sign up for free to get an API token) 
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://eodhd.com/api/fundamentals/GSPC.INDX?api_token={YOUR_API_TOKEN}&fmt=json',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'GET',
));

$data = curl_exec($curl);
curl_close($curl);

try {
    $data = json_decode($data, true, 512, JSON_THROW_ON_ERROR);
    var_dump($data);
} catch (Exception $e) {
    echo 'Error. '.$e->getMessage();
}
(Sign up for free to get an API token) 
import requests

url = f'https://eodhd.com/api/fundamentals/GSPC.INDX?api_token={YOUR_API_TOKEN}&fmt=json'
data = requests.get(url).json()

print(data)
(Sign up for free to get an API token) 
library(httr)
library(jsonlite)

url <- 'https://eodhd.com/api/fundamentals/GSPC.INDX?api_token={YOUR_API_TOKEN}&fmt=json'
response <- GET(url)

if (http_type(response) == "application/json") {
    content <- content(response, "text", encoding = "UTF-8")
    cat(content)
} else {
    cat("Error while receiving data\n")
}
(Sign up for free to get an API token)

Response example for S&P 500 (GSPC.INDX):

Index Constituents

Historical Constituents for the S&P 500 (GSPC)

Through the Fundamentals API package, Historical data for the S&P 500 (also known as GSPC or simply S&P) is available in the form of snapshots for each date, providing the list of all 500 components for a specific date. We track the data from the 1960s, though the most complete data starts from 2016.

Parameters:

  • historical=1 : Adds historical snapshot data to the response under the “HistoricalComponents” section.
  • from= and to= : Additional parameters to set the time period. These only take effect if changes occurred during the specified period. Without these parameters, the entire dataset will be returned.

If you are looking for historical data not only for the S&P 500 but also for other S&P and Dow Jones indices, take a look at our new product available on our API Marketplace. For 30 major S&P and Dow Jones indices (see the list on our product page), this endpoint offers 2 to 12 years of historical records, marking each addition and exclusion of a component with the corresponding date.

Request example:

URL
cURL
PHP
Python
R
https://eodhd.com/api/fundamentals/GSPC.INDX?historical=1&from=2020-01-01&to=2023-01-01&api_token={YOUR_API_TOKEN}&fmt=json
(Sign up for free to get an API token) 
curl --location "https://eodhd.com/api/fundamentals/GSPC.INDX?historical=1&from=2020-01-01&to=2023-01-01&api_token={YOUR_API_TOKEN}&fmt=json"
(Sign up for free to get an API token) 
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://eodhd.com/api/fundamentals/GSPC.INDX?historical=1&from=2020-01-01&to=2023-01-01&api_token={YOUR_API_TOKEN}&fmt=json',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'GET',
));

$data = curl_exec($curl);
curl_close($curl);

try {
    $data = json_decode($data, true, 512, JSON_THROW_ON_ERROR);
    var_dump($data);
} catch (Exception $e) {
    echo 'Error. '.$e->getMessage();
}
(Sign up for free to get an API token) 
import requests

url = f'https://eodhd.com/api/fundamentals/GSPC.INDX?historical=1&from=2020-01-01&to=2023-01-01&api_token={YOUR_API_TOKEN}&fmt=json'
data = requests.get(url).json()

print(data)
(Sign up for free to get an API token) 
library(httr)
library(jsonlite)

url <- 'https://eodhd.com/api/fundamentals/GSPC.INDX?historical=1&from=2020-01-01&to=2023-01-01&api_token={YOUR_API_TOKEN}&fmt=json'
response <- GET(url)

if (http_type(response) == "application/json") {
    content <- content(response, "text", encoding = "UTF-8")
    cat(content)
} else {
    cat("Error while receiving data\n")
}
(Sign up for free to get an API token)

See the example below:

Bulk Fundamentals API

With the bulk fundamentals API endpoint, you will be able to download fundamental data for hundreds of companies in one request. To get access to the bulk fundamentals API, you should subscribe to the ‘Extended Fundamentals’ subscription plan, details of this plan are provided by request: support@eodhistoricaldata.com.

A subscription has access to 100 000 API calls per day (which can be increased by request at an additional cost). A regular fundamentals API request costs 10 API calls. For bulk fundamentals API, each request costs 100 API calls if symbols are not specified, and 100+number of symbols if the parameter symbols is used (a bulk fundamentals API request for 3 symbols will cost 103 API calls).

At the moment, due to the high loads of the request and some other reasons, this endpoint has several limitations:

  • It only supports stocks and doesn’t support ETFs and Mutual Funds.
  • By default, the parameter offset is set to 0 and limit to 500. If limit is larger than 500, it will be reset to 500.
  • The following US exchanges can be addressed separately in addition to the regular US code: NASDAQ, NYSE (or ‘NYSE MKT’), BATS and AMEX. All non-US exchanges are supported as is. Here is the full list of supported exchanges with codes.

This example will return fundamentals data for the NASDAQ exchange:

URL
cURL
PHP
Python
R
https://eodhd.com/api/bulk-fundamentals/NASDAQ?api_token={YOUR_API_TOKEN}&fmt=json
(Sign up for free to get an API token) 
curl --location "https://eodhd.com/api/bulk-fundamentals/NASDAQ?api_token={YOUR_API_TOKEN}&fmt=json"
(Sign up for free to get an API token) 
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://eodhd.com/api/bulk-fundamentals/NASDAQ?api_token={YOUR_API_TOKEN}&fmt=json',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'GET',
));

$data = curl_exec($curl);
curl_close($curl);

try {
    $data = json_decode($data, true, 512, JSON_THROW_ON_ERROR);
    var_dump($data);
} catch (Exception $e) {
    echo 'Error. '.$e->getMessage();
}
(Sign up for free to get an API token) 
import requests

url = f'https://eodhd.com/api/bulk-fundamentals/NASDAQ?api_token={YOUR_API_TOKEN}&fmt=json'
data = requests.get(url).json()

print(data)
(Sign up for free to get an API token) 
library(httr)
library(jsonlite)

url <- 'https://eodhd.com/api/bulk-fundamentals/NASDAQ?api_token={YOUR_API_TOKEN}&fmt=json'
response <- GET(url)

if (http_type(response) == "application/json") {
    content <- content(response, "text", encoding = "UTF-8")
    cat(content)
} else {
    cat("Error while receiving data\n")
}
(Sign up for free to get an API token)

The default data format is CSV. If you want a JSON output, the parameter &fmt=json is required. We recommend using the JSON output.

To get less data in one request, you can use the parameters offset and limit which work as a sort of pagination. limit – the number of symbols you will get, offset – the first symbol. To get 200 symbols starting with symbol number 1000: &limit=200 and offset=1000.

For example:

URL
cURL
PHP
Python
R
https://eodhd.com/api/bulk-fundamentals/NASDAQ?offset=500&limit=100&api_token={YOUR_API_TOKEN}&fmt=json
(Sign up for free to get an API token) 
curl --location "https://eodhd.com/api/bulk-fundamentals/NASDAQ?offset=500&limit=100&api_token={YOUR_API_TOKEN}&fmt=json"
(Sign up for free to get an API token) 
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://eodhd.com/api/bulk-fundamentals/NASDAQ?offset=500&limit=100&api_token={YOUR_API_TOKEN}&fmt=json',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'GET',
));

$data = curl_exec($curl);
curl_close($curl);

try {
    $data = json_decode($data, true, 512, JSON_THROW_ON_ERROR);
    var_dump($data);
} catch (Exception $e) {
    echo 'Error. '.$e->getMessage();
}
(Sign up for free to get an API token) 
import requests

url = f'https://eodhd.com/api/bulk-fundamentals/NASDAQ?offset=500&limit=100&api_token={YOUR_API_TOKEN}&fmt=json'
data = requests.get(url).json()

print(data)
(Sign up for free to get an API token) 
library(httr)
library(jsonlite)

url <- 'https://eodhd.com/api/bulk-fundamentals/NASDAQ?offset=500&limit=100&api_token={YOUR_API_TOKEN}&fmt=json'
response <- GET(url)

if (http_type(response) == "application/json") {
    content <- content(response, "text", encoding = "UTF-8")
    cat(content)
} else {
    cat("Error while receiving data\n")
}
(Sign up for free to get an API token)

It’s also easy to get the data for several symbols instead of the entire exchange, just add the parameter &symbols=, in this case, the exchange code is ignored:

URL
cURL
PHP
Python
R
https://eodhd.com/api/bulk-fundamentals/NASDAQ?&symbols=AAPL.US,MSFT.US&api_token={YOUR_API_TOKEN}&fmt=json
(Sign up for free to get an API token) 
curl --location "https://eodhd.com/api/bulk-fundamentals/NASDAQ?&symbols=AAPL.US,MSFT.US&api_token={YOUR_API_TOKEN}&fmt=json"
(Sign up for free to get an API token) 
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'https://eodhd.com/api/bulk-fundamentals/NASDAQ?&symbols=AAPL.US,MSFT.US&api_token={YOUR_API_TOKEN}&fmt=json',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => '',
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 0,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => 'GET',
));

$data = curl_exec($curl);
curl_close($curl);

try {
    $data = json_decode($data, true, 512, JSON_THROW_ON_ERROR);
    var_dump($data);
} catch (Exception $e) {
    echo 'Error. '.$e->getMessage();
}
(Sign up for free to get an API token) 
import requests

url = f'https://eodhd.com/api/bulk-fundamentals/NASDAQ?&symbols=AAPL.US,MSFT.US&api_token={YOUR_API_TOKEN}&fmt=json'
data = requests.get(url).json()

print(data)
(Sign up for free to get an API token) 
library(httr)
library(jsonlite)

url <- 'https://eodhd.com/api/bulk-fundamentals/NASDAQ?&symbols=AAPL.US,MSFT.US&api_token={YOUR_API_TOKEN}&fmt=json'
response <- GET(url)

if (http_type(response) == "application/json") {
    content <- content(response, "text", encoding = "UTF-8")
    cat(content)
} else {
    cat("Error while receiving data\n")
}
(Sign up for free to get an API token)

Bulk Fundamentals Output

Here you can find an example of bulk fundamentals API endpoint for Apple Inc (AAPL.US) and Microsoft Corporation MSFT.US) in CSV format. Almost all fields are kept the same as in fundamentals API, however, there are some changes:

  • There are fewer fields than on the singular template.
  • Historical data is available for the last 4 quarters and the last 4 years only.

The original bulk fundamentals API output has fewer fields than the currently available fields from the fundamentals template due to the original bulk API being developed based on then-existing fundamentals fields.

If you need to get the data as close as possible to the currently available template, add &version=1.2 to your request, the fields provided will much be the same as in the singular request output (e. g. Earnings Trends will not be omitted), with the 4 quarters/4 years limitation staying. Version 1.2 output will only be provided in json.

You may also be interested in EOD Historical Data API.

Fundamental Data Glossaries

Make sure to check our glossaries detailing the fields in the output of the Fundamentals API for common stock and ETFs!

Register & Get Data