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.
Quick jump:
- 1 Quick Start
- 2 Which Fundamental Data is supported by our APIs
- 3 Stocks Fundamentals Data API
- 4 Filter Fields and WEBSERVICE support
- 5 Equities Fundamentals Data API
- 6 ETFs Fundamentals Data API
- 7 Funds Fundamentals Data API
- 8 Index Constituents (or Index Components) API
- 9 Historical Constituents for Indices.
- 10 Bulk Fundamentals API
- 11 Fundamental Data Glossaries
Quick Start
To get a fundamental data feed, use the following URL:
https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json
curl --location "https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json"
$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();
}
import requests
url = f'https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json'
data = requests.get(url).json()
print(data)
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")
}
- 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):
https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json
curl --location "https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json"
$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(); }
import requests url = f'https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json' data = requests.get(url).json() print(data)
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") }
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
- Sharesoutstanding,
-
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:
https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json
curl --location "https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json"
$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(); }
import requests url = f'https://eodhd.com/api/fundamentals/AAPL.US?api_token=demo&fmt=json' data = requests.get(url).json() print(data)
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") }
As a result, you will get the following data in JSON format only (click on the image will open a page with JSON data).
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:
https://eodhd.com/api/fundamentals/AAPL.US?filter=General::Code&api_token=demo&fmt=json
curl --location "https://eodhd.com/api/fundamentals/AAPL.US?filter=General::Code&api_token=demo&fmt=json"
$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();
}
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)
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")
}
Different layers are divided with “::” and it’s possible to have any number of layers, you want, for example:
https://eodhd.com/api/fundamentals/AAPL.US?filter=Financials::Balance_Sheet::yearly&api_token=demo&fmt=json
curl --location "https://eodhd.com/api/fundamentals/AAPL.US?filter=Financials::Balance_Sheet::yearly&api_token=demo&fmt=json"
$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();
}
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)
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")
}
It’s also possible to use several, comma-separated, filters, for example:
https://eodhd.com/api/fundamentals/AAPL.US?filter=General::Code,General,Earnings&api_token=demo&fmt=json
curl --location "https://eodhd.com/api/fundamentals/AAPL.US?filter=General::Code,General,Earnings&api_token=demo&fmt=json"
$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();
}
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)
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")
}
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.
![](https://eodhistoricaldata.com/financial-apis/wp-content/uploads/2020/11/image.png)
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.
![Schwab S&P 500 Index Example](https://eodhistoricaldata.com/financial-apis/wp-content/uploads/2017/09/swpx_example.png)
Index Constituents (or Index Components) API
We provide Index Constituents (or Index Components) data for all major indices worldwide. It’s easy to use: simply request our fundamentals API with an index, and we will provide a list of tickers that are part of the specified index. We offer the following data for index components:
- Code.
- Exchange.
- Name.
- Sector.
- Industry.
The query example:
https://eodhd.com/api/fundamentals/GSPC.INDX?api_token={YOUR_API_TOKEN}&fmt=json
curl --location "https://eodhd.com/api/fundamentals/GSPC.INDX?api_token={YOUR_API_TOKEN}&fmt=json"
$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();
}
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)
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")
}
And below you can find an example of the output of index constituents for the S&P 500 (GSPC.INDX).
We offer a new standalone product dedicated to S&P and Dow Jones indices on our API Marketplace. This new product provides daily updated index components for over 100 indices, including the S&P 500, 600, 100, 400, DJ, and more. Visit our product page to learn more.
Historical Constituents for Indices.
We also provide historical constituents data for S&P 500 (or GSPC or just S&P). The data is available from 2010 (10+ years) and includes more than 500 tickers: active, non-active (previously included in S&P 500), and delisted.
And below you can find an example of the output of index constituents for the S&P 500 (GSPC.INDX)
![](https://eodhistoricaldata.com/financial-apis/wp-content/uploads/2020/06/image.png)
We offer a new standalone product dedicated to S&P and Dow Jones indices on our API Marketplace. For 30 major S&P and DJ indices (see the list on our product page), the endpoint offers 2-12 years of historical records, marking each addition and exclusion of a component with the corresponding date. Visit our product page to learn more.
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:
https://eodhd.com/api/bulk-fundamentals/NASDAQ?api_token={YOUR_API_TOKEN}&fmt=json
curl --location "https://eodhd.com/api/bulk-fundamentals/NASDAQ?api_token={YOUR_API_TOKEN}&fmt=json"
$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();
}
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)
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")
}
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:
https://eodhd.com/api/bulk-fundamentals/NASDAQ?offset=500&limit=100&api_token={YOUR_API_TOKEN}&fmt=json
curl --location "https://eodhd.com/api/bulk-fundamentals/NASDAQ?offset=500&limit=100&api_token={YOUR_API_TOKEN}&fmt=json"
$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();
}
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)
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")
}
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:
https://eodhd.com/api/bulk-fundamentals/NASDAQ?&symbols=AAPL.US,MSFT.US&api_token={YOUR_API_TOKEN}&fmt=json
curl --location "https://eodhd.com/api/bulk-fundamentals/NASDAQ?&symbols=AAPL.US,MSFT.US&api_token={YOUR_API_TOKEN}&fmt=json"
$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();
}
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)
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")
}
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!