### Install the Python Client

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Use pip to install the package.

```bash
pip install nasdaq-data-link
```

--------------------------------

### Install Nasdaq Data Link Package

Source: https://github.com/nasdaq/data-link-python/blob/main/README.md

Standard installation commands for the Python package.

```shell
pip install nasdaq-data-link
```

```shell
pip3 install nasdaq-data-link
```

--------------------------------

### Install Nasdaq Data Link Python Library

Source: https://github.com/nasdaq/data-link-python/blob/main/LONG_DESCRIPTION.rst

Use this command to install the package via the pip tool.

```bash
$ pip install nasdaq-data-link
```

--------------------------------

### Run an Individual Test Example

Source: https://github.com/nasdaq/data-link-python/blob/main/README.md

An example of running a specific unit test, targeting the 'test_datatable' file and the 'ExportDataTableTest' class.

```python
python -m unittest -v test.test_datatable.ExportDataTableTest.test_download_get_file_info
```

--------------------------------

### Run All Tests Locally

Source: https://github.com/nasdaq/data-link-python/blob/main/README.md

Execute all tests for the plugin across supported Python versions using tox. Ensure tox and virtualenv are installed.

```bash
tox
```

--------------------------------

### Get Database Fields

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Retrieve a list of available fields for a specific database. Use this to understand the structure of the data you can access.

```python
database = nasdaqdatalink.Database('WIKI')
database.data_fields()
=> ['name', 'downloads', 'id', 'premium', 'description', 'datasets_count', 'database_code', 'image']
```

--------------------------------

### Retrieve point-in-time data within a range

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_ANALYSTS.md

Use the from interval for a half-open range [start, end) or the between interval for an inclusive range [start, end].

```python
nasdaqdatalink.get_point_in_time('DATABASE/CODE', interval='from', start_date='2020-01-01', end_date='2020-02-01')
```

```python
nasdaqdatalink.get_point_in_time('DATABASE/CODE', interval='between', start_date='2020-01-01', end_date='2020-01-31')
```

--------------------------------

### Retrieve Multiple Codes as a Multiset

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_ANALYSTS.md

Fetches multiple datasets simultaneously by passing an array of codes to the get method.

```python
data = nasdaqdatalink.get(['WIKI/AAPL.11','WIKI/MSFT.11'])
```

--------------------------------

### Get List Values

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Retrieve the values from a list query. This is typically used after fetching a list of databases or datasets.

```python
databases = nasdaqdatalink.Database.all()
databases.values
```

--------------------------------

### Retrieve Time-Series Data

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Use get() to fetch time-series datasets as pandas DataFrames or NumPy arrays, with support for filtering, transformations, and multiset queries.

```python
import nasdaqdatalink

# Basic dataset retrieval - returns pandas DataFrame
data = nasdaqdatalink.get('NSE/OIL')
print(data.head())
#              High     Low    Open   Close      Volume
# Date
# 2010-01-04  1096.0  1082.0  1092.0  1093.55  23820558.0
# 2010-01-05  1098.0  1085.0  1098.0  1095.10  19aborskemment575898.0

# With date filtering and transformations
data = nasdaqdatalink.get(
    'NSE/OIL',
    start_date='2010-01-01',
    end_date='2014-01-01',
    collapse='annual',        # daily, weekly, monthly, quarterly, annual
    transform='rdiff',        # diff, rdiff, cumul, normalize
    rows=4,
    order='asc'               # asc or desc
)

# Get specific column (column index after dot)
data = nasdaqdatalink.get('WIKI/AAPL.11')  # Column 11 (Adj. Close)

# Multiset query - compare multiple datasets
data = nasdaqdatalink.get(['WIKI/AAPL.11', 'WIKI/MSFT.11'])
print(data.head())
#             WIKI/AAPL - Adj. Close  WIKI/MSFT - Adj. Close
# Date
# 1997-08-20                    6.16                   17.57
# 1997-08-21                    6.00                   17.23

# Return as NumPy array instead of pandas
data = nasdaqdatalink.get('NSE/OIL', returns='numpy')
```

--------------------------------

### Get List Metadata

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Retrieve metadata associated with a list query. This can include information like the current page, total results, etc.

```python
databases = nasdaqdatalink.Database.all()
databases.meta
```

--------------------------------

### Get Dataset Column Names and Fields

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Retrieve column names and data fields for a specific dataset. Note that API field names may be converted to Python-compatible names.

```python
data = nasdaqdatalink.Dataset('WIKI/AAPL').data(params={ 'limit': 1 })[0]

data.column_names
=> ["Date", "Open", "High", "Low", "Close", "Volume", "Ex-Dividend", "Split Ratio", "Adj. Open", "Adj. High", "Adj. Low", "Adj. Close", "Adj. Volume"]

data.data_fields()
=> ["date", "open", "high", "low", "close", "volume", "ex_dividend", "split_ratio", "adj_open", "adj_high", "adj_low", "adj_close", "adj_volume"]
```

--------------------------------

### Get Raw List Data

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Convert a list query result into a raw list format. Use this when you need the data in a simple list structure.

```python
databases = nasdaqdatalink.Database.all()
databases.to_list()
```

--------------------------------

### Download Bulk Databases

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Use bulkdownload() to retrieve an entire database as a zip file.

```python
import nasdaqdatalink

# Download entire database to current directory
filename = nasdaqdatalink.bulkdownload('EOD')
print(f"Downloaded to: {filename}")
```

--------------------------------

### Configure API Authentication

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Set your API key using environment variables, a local file, or direct assignment in your code.

```python
import nasdaqdatalink

# Option 1: Set API key directly
nasdaqdatalink.ApiConfig.api_key = 'your_api_key_here'

# Option 2: Read from custom file location
nasdaqdatalink.read_key(filename="/path/to/custom/apikey")

# Option 3: Save key to default location (~/.nasdaq/data_link_apikey)
nasdaqdatalink.save_key('your_api_key_here')

# Option 4: Set via environment variable (auto-loaded)
# export NASDAQ_DATA_LINK_API_KEY=your_api_key_here
```

--------------------------------

### nasdaqdatalink.bulkdownload()

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Downloads an entire database as a zip file.

```APIDOC
## GET nasdaqdatalink.bulkdownload()

### Description
Downloads the entire contents of a database as a compressed zip file.

### Parameters
#### Query Parameters
- **database_code** (string) - Required - The identifier for the database to download.
```

--------------------------------

### Perform Bulk Database Download

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_ANALYSTS.md

Downloads an entire database as a zip file to the current working directory.

```python
import nasdaqdatalink
nasdaqdatalink.bulkdownload('EOD')
```

```python
import nasdaqdatalink
nasdaqdatalink.bulkdownload('EOD', download_type='partial')
```

```python
import nasdaqdatalink
nasdaqdatalink.bulkdownload('EOD', filename='/my/path/EOD_DB.zip')
```

--------------------------------

### Retrieve Data via Quick Methods

Source: https://github.com/nasdaq/data-link-python/blob/main/README.md

Retrieve dataset or datatable information directly into a pandas DataFrame.

```python
import nasdaqdatalink
data = nasdaqdatalink.get('NSE/OIL')
```

```python
import nasdaqdatalink
data = nasdaqdatalink.get_table('ZACKS/FC', ticker='AAPL')
```

--------------------------------

### Enable Debug Logging

Source: https://github.com/nasdaq/data-link-python/blob/main/README.md

Configure the logging module to output debug information for the nasdaqdatalink logger.

```python
import nasdaqdatalink
import logging

logging.basicConfig()
# logging.getLogger().setLevel(logging.DEBUG)  # optionally set level for
everything.  Useful to see dependency debug info as well.

data_link_log = logging.getLogger("nasdaqdatalink")
data_link_log.setLevel(logging.DEBUG)
```

--------------------------------

### Load API Key from Custom Path

Source: https://github.com/nasdaq/data-link-python/blob/main/README.md

Explicitly load the API key from a specific file path instead of the default location.

```python
import nasdaqdatalink
nasdaqdatalink.read_key(filename="/data/.corporatenasdaqdatalinkapikey")
```

--------------------------------

### Run All Tests Locally

Source: https://github.com/nasdaq/data-link-python/blob/main/README.md

Execute all tests for the plugin locally. This command runs tests with warnings always enabled for thorough checking.

```python
python -W always setup.py -q test
```

--------------------------------

### API Configuration Options

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Configure API settings such as API key, retry behavior, and SSL verification. Recommended for production applications to ensure robust API handling.

```python
import nasdaqdatalink

# API Key
nasdaqdatalink.ApiConfig.api_key = 'your_api_key'

# Retry configuration
nasdaqdatalink.ApiConfig.use_retries = True
nasdaqdatalink.ApiConfig.number_of_retries = 5
nasdaqdatalink.ApiConfig.retry_backoff_factor = 0.5  # Exponential: 0.5, 1, 2, 4...
nasdaqdatalink.ApiConfig.max_wait_between_retries = 8
nasdaqdatalink.ApiConfig.retry_status_codes = [429, 500, 501, 502, 503, 504]

# SSL verification (not recommended to disable)
nasdaqdatalink.ApiConfig.verify_ssl = False

# Pagination limit
nasdaqdatalink.ApiConfig.page_limit = 100
```

--------------------------------

### Access List Metadata via Convenience Method

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Access specific metadata fields from a list query using convenience methods. This provides easy access to pagination and result information.

```python
nasdaqdatalink.Database.all().current_page
=> 1
```

--------------------------------

### Accessing Data Metadata and Fields

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Demonstrates how to access metadata and field names from a data object. Supports attribute or dictionary-style access for individual data points.

```python
print(data.meta)
# {'start_date': '2010-01-01', 'end_date': '2018-03-27', 'column_names': [...]}

row = data[0]
print(row.data_fields())
# ['date', 'open', 'high', 'low', 'close', 'volume', 'ex_dividend',
#  'split_ratio', 'adj_open', 'adj_high', 'adj_low', 'adj_close', 'adj_volume']

print(row.adj_close)
print(row['adj_close'])
```

--------------------------------

### Retrieve Database Metadata and Datasets

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Access database-level metadata, list all databases, or retrieve datasets within a database.

```python
db = nasdaqdatalink.Database('WIKI')
db.name
```

```python
dataset = nasdaqdatalink.Dataset('WIKI/AAPL')
dataset.database()
```

```python
nasdaqdatalink.Database.all()
```

```python
nasdaqdatalink.Database('WIKI').datasets()
```

--------------------------------

### Run an Individual Test

Source: https://github.com/nasdaq/data-link-python/blob/main/README.md

Execute a specific unit test by providing the test file, class, and individual test name. This is useful for debugging.

```python
python -m unittest test.[test file name].[class name].[individual test name]
```

--------------------------------

### Database Object Usage

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Manage database metadata and perform bulk downloads at the database level.

```python
import nasdaqdatalink

# Create database object
db = nasdaqdatalink.Database('WIKI')

# Access metadata
print(db.name)
print(db.database_code)
print(db.datasets_count)

# List all databases (paginated)
databases = nasdaqdatalink.Database.all()
for database in databases:
    print(database.database_code)

# Check for more results
if databases.has_more_results():
    more = nasdaqdatalink.Database.all(params={'page': 2})

# Get datasets in database
datasets = db.datasets()

# Get bulk download URL
url = db.bulk_download_url()
print(url)
# => "https://data.nasdaq.com/api/v3/databases/WIKI/data?api_key=..."

# Download database to file
db.bulk_download_to_file('/path/to/destination/')

# Download with options
db.bulk_download_to_file('.', params={'download_type': 'partial'})
```

--------------------------------

### Retrieve a Dataset in Python

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_ANALYSTS.md

Fetches all data points for a specified dataset and returns them as a pandas DataFrame.

```python
import nasdaqdatalink
data = nasdaqdatalink.get('NSE/OIL')
```

--------------------------------

### Retrieve point-in-time data as of a specific date

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_ANALYSTS.md

Use the asofdate interval to fetch data as it existed on a specific date.

```python
nasdaqdatalink.get_point_in_time('DATABASE/CODE', interval='asofdate', date='2020-01-01')
```

--------------------------------

### Export Datatable to Zip

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_ANALYSTS.md

Downloads entire datatables or filtered subsets as zip files to the local filesystem.

```python
import nasdaqdatalink
data = nasdaqdatalink.export_table('MER/F1')
```

```python
import nasdaqdatalink
data = nasdaqdatalink.export_table('MER/F1', filename='/my/path/db.zip')
```

```python
import nasdaqdatalink
nasdaqdatalink.export_table('ZACKS/FC',  ticker=['AAPL', 'MSFT'], per_end_date={'gte': '2015-01-01'}, qopts={'columns':['ticker', 'per_end_date']})
```

--------------------------------

### nasdaqdatalink.bulkdownload

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Downloads bulk data from a specified database.

```APIDOC
## nasdaqdatalink.bulkdownload

### Description
Downloads bulk data from a specified database as a zip file.

### Parameters
- **database_code** (string) - Required - The code of the database to download.
- **filename** (string) - Optional - The local path to save the zip file.
- **download_type** (string) - Optional - Type of download, e.g., 'partial' for changes only.
```

--------------------------------

### Retrieve Dataset with Filters and Transformations

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_ANALYSTS.md

Applies parameters like date ranges, collapse frequency, and transformations to streamline dataset results.

```python
import nasdaqdatalink
data = nasdaqdatalink.get('NSE/OIL', start_date='2010-01-01', end_date='2014-01-01',
                  collapse='annual', transformation='rdiff',
                  rows=4)
```

--------------------------------

### Database Object

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Provides access to database metadata and bulk download functionality.

```APIDOC
## Database Object

### Description
The Database class provides access to database-level metadata, lists of datasets, and bulk download URLs.

### Methods
- **all()**: Lists all available databases.
- **datasets()**: Returns a list of datasets within the database.
- **bulk_download_url()**: Returns the URL for bulk downloading the database.
- **bulk_download_to_file(path, params)**: Downloads the database to a local file.
```

--------------------------------

### View DataFrame Head in Python

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_ANALYSTS.md

Displays the first few rows of the retrieved pandas DataFrame.

```python
data.head()
```

--------------------------------

### nasdaqdatalink.get()

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Retrieves time-series dataset data and returns it as a pandas DataFrame or NumPy array.

```APIDOC
## GET nasdaqdatalink.get()

### Description
Retrieves time-series dataset data. Supports single datasets, specific columns, and multiset queries.

### Parameters
#### Query Parameters
- **dataset_code** (string) - Required - The identifier for the dataset (e.g., 'NSE/OIL').
- **start_date** (string) - Optional - Start date for data retrieval.
- **end_date** (string) - Optional - End date for data retrieval.
- **collapse** (string) - Optional - Frequency of data (daily, weekly, monthly, quarterly, annual).
- **transform** (string) - Optional - Data transformation (diff, rdiff, cumul, normalize).
- **rows** (integer) - Optional - Number of rows to return.
- **order** (string) - Optional - Sort order (asc or desc).
- **returns** (string) - Optional - Format of returned data (pandas or numpy).
```

--------------------------------

### Configure SSL Verification

Source: https://github.com/nasdaq/data-link-python/blob/main/README.md

Disable SSL verification for the API client. This is not recommended for production environments.

```python
nasdaqdatalink.ApiConfig.verify_ssl = False
```

--------------------------------

### Fetch Next Page of Results

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Fetch the next page of results for a list query. Pass the desired page number in the params dictionary.

```python
nasdaqdatalink.Database.all(params={ 'page': 2 })
=> ... more results ...
```

--------------------------------

### Create and Retrieve Merged Datasets

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Combine multiple datasets into a single object and retrieve the merged data.

```python
merged_dataset = nasdaqdatalink.MergedDataset([('WIKI/AAPL', {'column_index': [11]}),
                                           ('WIKI/MSFT', {'column_index': [9,11]}), 'WIKI/TWTR'])
```

```python
data = merged_dataset.data()
```

--------------------------------

### Bulk Download Database Data

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Methods for generating a download URL or saving database data directly to a file. Authentication via api_key is required for premium databases.

```python
nasdaqdatalink.Database('ZEA').bulk_download_url()
=> "https://data.nasdaq.com/api/v3/databases/ZEA/data?api_key=tEsTkEy123456789"
```

```python
nasdaqdatalink.Database('ZEA').bulk_download_to_file('/path/to/destination/folder_or_file_path')
```

```python
nasdaqdatalink.Database('ZEA').bulk_download_to_file('.', params={'download_type': 'partial'})
```

--------------------------------

### nasdaqdatalink.get_table()

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Retrieves datatable data with flexible filtering options and pagination support.

```APIDOC
## GET nasdaqdatalink.get_table()

### Description
Retrieves non-time-series datatable data. Supports filtering by column values and pagination.

### Parameters
#### Query Parameters
- **table_code** (string) - Required - The identifier for the datatable (e.g., 'ZACKS/FC').
- **paginate** (boolean) - Optional - Enable pagination for large datasets.
- **qopts** (dict) - Optional - Query options including column selection.
```

--------------------------------

### Bulk Download Data

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Download bulk data files with options for specific paths or partial updates.

```python
# Download to specific path
filename = nasdaqdatalink.bulkdownload('EOD', filename='/my/path/EOD_DB.zip')

# Partial download (only changes from previous day)
filename = nasdaqdatalink.bulkdownload('EOD', download_type='partial')
```

--------------------------------

### Retrieve Datatable Information

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_ANALYSTS.md

Fetches the first page of a datatable. Use pagination to retrieve and merge multiple pages of data.

```python
import nasdaqdatalink
data = nasdaqdatalink.get_table('ZACKS/FC')
```

```python
import nasdaqdatalink
data = nasdaqdatalink.get_table('ZACKS/FC', paginate=True)
```

--------------------------------

### Retrieve Point in Time Data

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_ANALYSTS.md

Queries data for a specific interval and date using ISO8601 formatting.

```python
import nasdaqdatalink
data = nasdaqdatalink.get_point_in_time('DATABASE/CODE', interval='asofdate', date='2020-01-01')
```

--------------------------------

### Convert Data Formats

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Transform retrieved data into common formats like CSV, pandas DataFrames, NumPy records, or lists.

```python
data.to_csv()
=> "Id,Name,Database Code,Description,Datasets Count,Downloads,Premium,Image,Bundle Ids,Plan ...
```

```python
data.to_pandas()
```

```python
data.to_numpy()
```

```python
data.to_list()
```

--------------------------------

### Access Database Attributes

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Access database attributes directly using dot notation or dictionary-like lookup. This is useful for quickly retrieving specific metadata about a database.

```python
database = nasdaqdatalink.Database('WIKI')
database.database_code
=> 'WIKI'
database['database_code']
=> 'WIKI'
```

--------------------------------

### Access List Metadata via Hash Lookup

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Access specific metadata fields from a list query using dictionary-like lookup. This is an alternative to convenience methods for accessing metadata.

```python
nasdaqdatalink.Database.all()['current_page']
=> 1
```

--------------------------------

### Dataset Object Usage

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Access time-series data and metadata using the Dataset class.

```python
import nasdaqdatalink

# Create dataset object
dataset = nasdaqdatalink.Dataset('WIKI/AAPL')

# Get data with parameters
data = dataset.data(params={
    'start_date': '2001-01-01',
    'end_date': '2010-01-01',
    'collapse': 'annual',
    'transformation': 'rdiff',
    'rows': 4
})

# Access individual data points
print(data[0].date)
print(data[0].close)

# Get available metadata fields
print(dataset.data_fields())
# ['premium', 'name', 'frequency', 'description', 'column_names',
#  'database_code', 'type', 'refreshed_at', 'newest_available_date',
#  'dataset_code', 'oldest_available_date', 'database_id', 'id']

# Access metadata
print(dataset.name)
print(dataset.column_names)

# Get parent database
database = dataset.database()
```

--------------------------------

### Retrieve Dataset Data

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Basic retrieval of dataset information and retrieval with optional query parameters.

```python
data = nasdaqdatalink.Dataset('WIKI/AAPL').data()
```

```python
dataset_data = nasdaqdatalink.Dataset('WIKI/AAPL').data(params={ 'start_date':'2001-01-01', 'end_date':'2010-01-01', 'collapse':'annual', 'transformation':'rdiff', 'rows':4 })
```

--------------------------------

### Export Datatables

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Download entire datatables as zip files, with support for filtering and custom file paths.

```python
import nasdaqdatalink

# Download entire table
nasdaqdatalink.export_table('MER/F1')

# Download to specific location
nasdaqdatalink.export_table('MER/F1', filename='/my/path/table.zip')

# Download with filters
nasdaqdatalink.export_table(
    'ZACKS/FC',
    ticker=['AAPL', 'MSFT'],
    per_end_date={'gte': '2015-01-01'},
    qopts={'columns': ['ticker', 'per_end_date']}
)
```

--------------------------------

### Iterate Datatable Pages

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Retrieving all pages of datatable data using a loop and cursor IDs.

```python
data_list = []
cursor_id = None
while True:
    data = nasdaqdatalink.Datatable('ZACKS/FC').data(params={'ticker': ['AAPL','MSFT'], 'per_end_date': {'gte': '2015-01-01'}, 'qopts': {'columns': ['ticker', 'comp_name'], 'cursor_id': cursor_id}})
    cursor_id = data.meta['next_cursor_id']
    data_list.append(data)
    if cursor_id is None:
        break
```

--------------------------------

### Access Dataset Columns

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Accessing specific data fields using mapped column names.

```python
dataset_data[0].date
```

--------------------------------

### nasdaqdatalink.export_table

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Downloads an entire datatable as a zip file with optional filtering.

```APIDOC
## nasdaqdatalink.export_table

### Description
Downloads an entire datatable as a zip file with optional filtering parameters.

### Parameters
- **datatable_code** (string) - Required - The code of the datatable.
- **filename** (string) - Optional - The local path to save the zip file.
- **filters** (dict) - Optional - Filtering criteria such as ticker or date ranges.
```

--------------------------------

### Data Retrieval Intervals

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_ANALYSTS.md

The `get_point_in_time` function allows fetching data with different interval options to specify the date range.

```APIDOC
## GET /nasdaq/data-link-python

### Description
This section describes the different interval options available for retrieving data using the `nasdaqdatalink.get_point_in_time` function.

### Method
GET (Conceptual - actual implementation is via SDK function calls)

### Endpoint
`/nasdaq/data-link-python` (Conceptual SDK usage)

### Parameters
#### Query Parameters
- **interval** (string) - Required - Specifies the data retrieval interval. Options: 'asofdate', 'from', 'between'.
- **date** (string) - Required for 'asofdate' interval - The specific date to retrieve data for (YYYY-MM-DD).
- **start_date** (string) - Required for 'from' and 'between' intervals - The start date for the data range (YYYY-MM-DD).
- **end_date** (string) - Required for 'from' and 'between' intervals - The end date for the data range (YYYY-MM-DD).

### Request Example
```python
# Example for 'asofdate' interval
nasdaqdatalink.get_point_in_time('DATABASE/CODE', interval='asofdate', date='2020-01-01')

# Example for 'from' interval
nasdaqdatalink.get_point_in_time('DATABASE/CODE', interval='from', start_date='2020-01-01', end_date='2020-02-01')

# Example for 'between' interval
nasdaqdatalink.get_point_in_time('DATABASE/CODE', interval='between', start_date='2020-01-01', end_date='2020-01-31')
```

### Response
#### Success Response (200)
- **data** (object/array) - The retrieved data based on the specified interval and dates.

#### Response Example
(Response structure depends on the data source and interval used. Refer to specific data source documentation for details.)
```

--------------------------------

### nasdaqdatalink.get_point_in_time()

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Retrieves point-in-time data for datatables based on specific dates or ranges.

```APIDOC
## GET nasdaqdatalink.get_point_in_time()

### Description
Retrieves historical data snapshots for datatables, useful for backtesting.

### Parameters
#### Query Parameters
- **database_code** (string) - Required - The identifier for the database.
- **interval** (string) - Required - The type of interval (asofdate, from, between).
- **date** (string) - Optional - Specific date for 'asofdate' interval.
- **start_date** (string) - Optional - Start date for range intervals.
- **end_date** (string) - Optional - End date for range intervals.
- **paginate** (boolean) - Optional - Enable pagination.
```

--------------------------------

### Dataset Object

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Provides object-oriented access to time-series data and metadata.

```APIDOC
## Dataset Object

### Description
The Dataset class allows for retrieving time-series data and associated metadata for a specific dataset.

### Methods
- **data(params)**: Retrieves data based on parameters like start_date, end_date, collapse, and transformation.
- **data_fields()**: Returns a list of available metadata fields.
- **database()**: Returns the parent Database object.
```

--------------------------------

### Datatable Object Usage

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Access non-time-series data with support for manual pagination and file downloads.

```python
import nasdaqdatalink

# Create datatable object
dt = nasdaqdatalink.Datatable('ZACKS/FC')

# Get metadata
print(dt.data_fields())

# Get data with manual pagination
data = dt.data()
print(data.to_pandas().head())

# Handle pagination manually
cursor_id = data.meta['next_cursor_id']
if cursor_id:
    data2 = dt.data(params={'qopts': {'cursor_id': cursor_id}})

# Complete pagination example
data_list = []
cursor_id = None
while True:
    params = {
        'ticker': ['AAPL', 'MSFT'],
        'per_end_date': {'gte': '2015-01-01'},
        'qopts': {
            'columns': ['ticker', 'comp_name'],
            'cursor_id': cursor_id
        }
    }
    data = nasdaqdatalink.Datatable('ZACKS/FC').data(params=params)
    data_list.append(data)
    cursor_id = data.meta['next_cursor_id']
    if cursor_id is None:
        break

# Download full table as zip
dt.download_file('/path/to/download/')
```

--------------------------------

### Retrieve Dataset Metadata

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Access metadata for specific datasets using their unique codes.

```python
nasdaqdatalink.Dataset('WIKI/AAPL')
```

```python
nasdaqdatalink.Dataset('WIKI/AAPL').data_fields()
=> ['premium', 'name', 'frequency', 'description', 'column_names', 'database_code', 'type', 'refreshed_at', 'newest_available_date', 'dataset_code', 'oldest_available_date', 'database_id', 'id']
```

--------------------------------

### Data Format Conversion

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Convert retrieved data objects into various formats like pandas DataFrames, NumPy arrays, or CSV strings.

```python
import nasdaqdatalink

# Get data
data = nasdaqdatalink.Dataset('WIKI/AAPL').data(params={'limit': 10})

# Convert to pandas DataFrame
df = data.to_pandas()

# Convert to NumPy array
np_array = data.to_numpy()

# Convert to CSV string
csv_str = data.to_csv()

# Convert to raw list
raw_list = data.to_list()
```

--------------------------------

### Iterate Through List Results

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Loop through the results of a list query. Note that this only iterates over the currently loaded page of data.

```python
databases = nasdaqdatalink.Database.all()
for database in databases:
    print(database.database_code)
=> ... print database codes ...

more_databases = nasdaqdatalink.Database.all(params={ 'page': 2 })
for database in more_databases:
    print(database.database_code)
=> ... print more database codes ...
```

--------------------------------

### PointInTime Object for Datatables

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Utilize the PointInTime object for object-oriented access to point-in-time data. Supports fetching data as a list or pandas DataFrame, and querying date ranges.

```python
import nasdaqdatalink

# Create PointInTime object
pit = nasdaqdatalink.PointInTime(
    'DATATABLE/CODE',
    pit={'interval': 'asofdate', 'date': '2020-01-01'}
)

# Get data as list
data = pit.data().to_list()

# Get data as pandas
df = pit.data().to_pandas()

# Date range query
pit = nasdaqdatalink.PointInTime(
    'DATATABLE/CODE',
    pit={
        'interval': 'from',
        'start_date': '2020-01-01',
        'end_date': '2020-01-15'
    }
)
data = pit.data()
```

--------------------------------

### Retrieve Datatable Data

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Use get_table() to access non-time-series data structures with support for filtering, pagination, and column selection.

```python
import nasdaqdatalink

# Basic datatable retrieval (first page only)
data = nasdaqdatalink.get_table('ZACKS/FC')

# With filtering
data = nasdaqdatalink.get_table(
    'ZACKS/FC',
    ticker='AAPL'
)

# With pagination enabled to get more data
data = nasdaqdatalink.get_table(
    'ZACKS/FC',
    paginate=True,
    ticker=['AAPL', 'MSFT'],
    per_end_date={'gte': '2015-01-01'},  # greater than or equal
    qopts={'columns': ['ticker', 'per_end_date', 'comp_name']}
)

print(data.head())
#   ticker  per_end_date      comp_name
# 0   AAPL    2015-03-31      Apple Inc
# 1   AAPL    2015-06-30      Apple Inc
```

--------------------------------

### Datatable Object

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Provides object-oriented access to non-time-series data with pagination support.

```APIDOC
## Datatable Object

### Description
The Datatable class handles non-time-series data, supporting filtering and manual pagination via cursor IDs.

### Methods
- **data(params)**: Retrieves datatable records.
- **download_file(path)**: Downloads the full datatable as a zip file.
```

--------------------------------

### Retrieve Point in Time Data

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Query datatable information based on specific dates or intervals.

```python
data = nasdaqdatalink.PointInTime('DATATABLE/CODE', pit={'interval': 'asofdate', 'date': '2020-01-01'}).data().to_list()
data = nasdaqdatalink.PointInTime('DATATABLE/CODE', pit={'interval': 'asofdate', 'date': '2020-01-01'}).data().to_pandas()
# or
data = nasdaqdatalink.PointInTime('DATATABLE/CODE', pit={'interval': 'from', 'start_date': '2020-01-01', 'end_date': '2020-01-15'}).data()
```

--------------------------------

### Retrieve Datatable Data

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Basic retrieval of datatable information and handling paginated results using cursor IDs.

```python
data = nasdaqdatalink.Datatable('ZACKS/FC').data()
```

```python
data2 = nasdaqdatalink.Datatable('ZACKS/FC').data(params={'qopts': {'cursor_id': data.meta['next_cursor_id']}})
```

--------------------------------

### Check for More Results in Paginated List

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Determine if there are more results available in a paginated list. This is crucial for iterating through large datasets.

```python
databases = nasdaqdatalink.Database.all()
=> ... results ...
databases.has_more_results()
=> true
```

--------------------------------

### Filter Datatable Queries

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_ANALYSTS.md

Applies filters and column selection to datatable requests to avoid exceeding request limits.

```python
import nasdaqdatalink
data = nasdaqdatalink.get_table('ZACKS/FC', paginate=True, ticker=['AAPL', 'MSFT'], per_end_date={'gte': '2015-01-01'}, qopts={'columns':['ticker', 'per_end_date']})
```

--------------------------------

### Retrieve Point-in-Time Data

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Use get_point_in_time() to filter datatable results based on specific dates or ranges for historical analysis.

```python
import nasdaqdatalink

# Get data as of a specific date
data = nasdaqdatalink.get_point_in_time(
    'DATABASE/CODE',
    interval='asofdate',
    date='2020-01-01'
)

# Get data from a date range [start, end)
data = nasdaqdatalink.get_point_in_time(
    'DATABASE/CODE',
    interval='from',
    start_date='2020-01-01',
    end_date='2020-02-01'
)

# Get data between dates (inclusive) [start, end]
data = nasdaqdatalink.get_point_in_time(
    'DATABASE/CODE',
    interval='between',
    start_date='2020-01-01',
    end_date='2020-01-31',
    paginate=True  # Enable pagination for large results
)

# Valid date formats (ISO 8601):
# '2021-03-02'
# '2021-03-02T13:45:00'
# '2021-03-02T12:55:00-05:00'
```

--------------------------------

### Retrieve Datatable Metadata

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Access metadata fields for a specific datatable.

```python
dt = nasdaqdatalink.Datatable('ZACKS/FC')
dt.data_fields()
```

--------------------------------

### Filter Datatable Results

Source: https://github.com/nasdaq/data-link-python/blob/main/FOR_DEVELOPERS.md

Applying filters to reduce the number of pages returned in a datatable query.

```python
data = nasdaqdatalink.Datatable('ZACKS/FC').data(params={'ticker': ['AAPL','MSFT'], 'per_end_date': {'gte': '2015-01-01'}, 'qopts': {'columns': ['ticker', 'comp_name']}}, qopts={'columns':['ticker', 'per_end_date']})
```

--------------------------------

### MergedDataset

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Combines multiple datasets into a single merged dataframe.

```APIDOC
## MergedDataset

### Description
Combines multiple datasets into a single merged dataframe for comparative analysis.

### Methods
- **data(params)**: Retrieves the merged data based on specified parameters.
```

--------------------------------

### MergedDataset Usage

Source: https://context7.com/nasdaq/data-link-python/llms.txt

Combine multiple datasets into a single dataframe for comparative analysis.

```python
import nasdaqdatalink

# Create merged dataset with specific columns
merged = nasdaqdatalink.MergedDataset([
    ('WIKI/AAPL', {'column_index': [11]}),      # Adj. Close only
    ('WIKI/MSFT', {'column_index': [9, 11]}),   # Columns 9 and 11
    'WIKI/TWTR'                                  # All columns
])

# Get merged data
data = merged.data()

# Convert to pandas
df = data.to_pandas()
print(df.head())
#             WIKI/AAPL - Adj. Close  WIKI/MSFT - Adj. Open  WIKI/MSFT - Adj. Close  ...
# Date
# 2013-11-07                  74.29                  35.48                   36.00  ...

# Get merged data with parameters
data = merged.data(params={
    'start_date': '2015-01-01',
    'end_date': '2020-01-01',
    'order': 'desc'
})

# Access metadata
print(merged.column_names)
print(merged.oldest_available_date)
print(merged.newest_available_date)
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.