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
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_ID}, 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
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
    • 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
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).

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
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:

URL
cURL
PHP
Python
R
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:

URL
cURL
PHP
Python
R
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.

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

Index Constituents (or Index Components) API

We provide Index Constituents (or Index Components) data for all major indices all around the world. It’s easy to use it, request our fundamentals API with an index and we will provide a list of tickers that are part of a provided index. We offer the following data for index components:

  • Code.
  • Exchange.
  • Name.
  • Sector.
  • Industry.

The query example:

URL
cURL
PHP
Python
R
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).

Index Constituents


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)

Bulk Fundamentals API

In addition, we do provide bulk fundamentals API. With this endpoint, you will be able to download fundamental data for thousands of companies in one request. At the moment, due to the high loads of the request, this endpoint has several limitations.

  • It supports only stocks and doesn’t support ETFs and Mutual Funds, these types of assets will be implemented later.
  • 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.
  • To get access to bulk fundamentals API, you should subscribe to the ‘Extended Fundamentals’ package, more details we will provide by request: support@eodhistoricaldata.com.
  • By default offset = 0 and limit = 500. If the ‘limit’ parameter is bigger than 500, it will be reset to 500.

The following 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
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")
}

By default, we do provide data in CSV format, if you want JSON output, add ‘fmt=json’ parameter. We recommend using the JSON output though. For example:

To get fewer data in one request, you can use two parameters ‘offset’ and ‘limit’. 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
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")
}

‘limit’ – the number of symbols you will get, and ‘offset’ – the first symbol, to get 200 symbols starting from 1000: limit=200 and offset=1000. In this case, you can reduce the amount of data and get all symbols in two or three queries, like pagination.

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 will be 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
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

We do provide bulk fundamentals both in CSV and JSON formats. 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:

  • Earning Trends data removed.
  • Historical data is available for the last 4 quarters and the last 4 years only.

To get access to bulk fundamentals API, one needs a subscription to the ‘Extended Fundamentals’ package, we provide details of it by request: support@eodhistoricaldata.com.

We have API limits 100 000 requests per day. Each symbol request costs 10 API calls. For bulk fundamentals API, each request costs 100 API calls.

You may also be interested in EOD Historical Data API.

Register & Get Data