Polygon.io is proud to offer extensive financial datasets, easily accessible thanks to S3. This guide provides detailed steps on setting up various S3 clients to efficiently retrieve the data you need.

### Pre-requisites:

A valid flat files subscription with Polygon.io, after which you will receive unique authentication keys. We have standardized the endpoint and bucket details for all users as follows:

Endpoint: `https://files.polygon.io`
Bucket: `flatfiles`

### Supported S3 Clients

Polygon.io rigorously tests and supports four widely recognized S3 clients to ensure compatibility and user convenience. These include:

1. **AWS S3 CLI**
2. **Rclone**
3. **MinIO**
4. **Python Boto3 SDK**

Below, you’ll find the setup process for each client.

### AWS S3 CLI

The AWS S3 Command Line Interface (CLI) is a powerful tool designed to interact with Amazon S3.

Here’s how to get started:

- Install the AWS S3 CLI from the [official website](https://aws.amazon.com/cli/).
- Run `aws configure` in your command line and enter your Access Key ID, Secret Access Key, and default region when prompted.
- To interact with Polygon.io's S3 files, use the following structured command:

```
aws s3 ls s3://flatfiles/ --endpoint-url https://files.polygon.io
```

### Rclone

Rclone facilitates data synchronization between your local system and S3 storage. Follow these steps to configure Rclone with Polygon.io:

- Download and install Rclone from [here](https://rclone.org/downloads/).
- Initiate a new remote storage configuration with `rclone config`.
- Here's an example configuration is provided below for reference:

```
[s3]
type = s3
env_auth = false
access_key_id = [ACCESS_KEY_ID]
secret_access_key = [SECRET_ACCESS_KEY]
endpoint = https://files.polygon.io
```
d. After configuration, you can interact with your storage using commands like `rclone ls s3:flatfiles`.

### MinIO

MinIO client works seamlessly with any S3 compatible cloud storage. Here’s how to configure it with Polygon.io:

- If you haven't already, download and set up MinIO from [their documentation](https://docs.min.io/docs/minio-client-quickstart-guide).
- Modify your `.mc/config.json` file with the configuration shown below:

```
   {
           "version": "10",
           "aliases": {
                   "s3": {
                           "url": "https://files.polygon.io",
                           "accessKey": "YourAccessKey",
                           "secretKey": "YourSecretKey",
                           "api": "S3v4",
                           "path": "auto"
                   }
           }
   }
```

- Your client is now ready for use with commands specific to MinIO.

### Python Boto3 SDK

Boto3 is the Amazon Web Services (AWS) SDK for Python, which enables Python developers to write software that makes use of Amazon services like S3. To set it up, follow these steps:

- Install Boto3 by running `pip install boto3` if you haven't already.
- Utilize the following script to interact with Polygon.io data:

```
   import boto3
   from botocore.client import Config

   # Initialize a session using your credentials
   session = boto3.Session(
       aws_access_key_id='YOUR_ACCESS_KEY',
       aws_secret_access_key='YOUR_SECRET_KEY',
   )

   # Create a client with your session and specify the endpoint
   s3 = session.client(
       's3',
       endpoint_url='https://files.polygon.io',
       config=Config(signature_version='s3v4'),
   )

   # List buckets, objects, or perform any other operations
   for key in s3.list_objects(Bucket='flatfiles')['Contents']:
       print(key['Key'])
```

c. This script initiates a session with your credentials, establishes a client connection, and lists all files available in the specified bucket.

### Next Steps

By following the steps outlined for each client, you can efficiently set up your systems to access extensive financial datasets from Polygon.io via S3. or further assistance or more advanced setup options, please refer to the respective client’s official documentation.

How to Get Started with S3 on Polygon.io

Yes, Polygon does support Greeks data for all index option contracts. When querying for this data, you need to prefix the underlying index symbol with “I:“. For instance, to query for the SPX index, your API request would look like this:
https://api.polygon.io/v3/snapshot/options/I:SPX?apiKey=***
 
 
Here is an example response:
 
 
```
{
 "results": [
 {
 "day": {
 "change": 0.35,
 "change_percent": 25.926,
 "close": 1.7,
 "high": 3.5,
 "last_updated": 1689120000000000000,
 "low": 1.35,
 "open": 3.3,
 "previous_close": 1.35,
 "volume": 41840,
 "vwap": 2.5245
 },
 "details": {
 "contract_type": "call",
 "exercise_style": "european",
 "expiration_date": "2023-07-12",
 "shares_per_contract": 100,
 "strike_price": 4500,
 "ticker": "O:SPXW230712C04500000"
 },
 "greeks": {
 "delta": 0.1747164662893937,
 "gamma": 0.015204164984227357,
 "theta": -5.994369119247097,
 "vega": 0.38594323616299553
 },
 "implied_volatility": 0.11856240507153987,
 "last_quote": {
 "ask": 1.65,
 "ask_size": 37,
 "bid": 1.6,
 "bid_size": 123,
 "last_updated": 1689174023516476700,
 "midpoint": 1.625,
 "timeframe": "REAL-TIME"
 },
 "last_trade": {
 "sip_timestamp": 1689174023261703200,
 "conditions": [
 209
 ],
 "price": 1.65,
 "size": 1,
 "exchange": 302,
 "timeframe": "REAL-TIME"
 },
 "open_interest": 4501,
 "underlying_asset": {
 "last_updated": 1680814651655000000,
 "value": 4483.78,
 "ticker": "I:SPX",
 "timeframe": "REAL-TIME"
 }
 }
```

Does Polygon support Greeks for index option contracts?

Yes, polygon supports option contracts for all index contracts. 


Does Polygon support options data for index contracts?

Reading option symbols can be quite confusing at first glance. An option contract symbol is separated into 4 parts. First is the underlying stock ticker. Next is the expiration date in YYMMDD format. Then the option type is listed, “C” for call or “P” for put. Last, is the strike price, also known as the exercise price. This value includes three decimal places. A simple way of calculating this value is to divide the strike price part of the option ticker by 1000. 
 
Example - January 21, 2022 Call Option for Uber with a $50 Strike Price
 
 
UBER220121C00050000 = UBER + 220121 + C + 00050000
 
 
Underlying Stock - UBER 
Expiration Date - January 21st, 2022 or ‘220121’ (YYMMDD) 
Option Type - Call or ‘C’ 
Strike Price - 00050000 (50000/1000) or $50 
 
You can read more about this in our blog post - [How to Read a Stock Options Ticker](https://polygon.io/blog/how-to-read-a-stock-options-ticker/ "How to Read a Stock Options Ticker")

How do you read an Options Symbol? 

We receive our options data directly from the Options Price Reporting Authority (OPRA). OPRA disseminates consolidated last sale and quotation information originating from the national securities exchanges that have been approved by the Securities and Exchange Commission (SEC) to provide markets for the listing and trading of exchange-traded securities options. This allows us to provide accurate and reliable options market data to our customers.

Where does Polygon’s Options data come from?

There is no limitation on our side to the number of tickers you can subscribe to at once as long as you can consume the data fast enough. You can subscribe to all tickers and all events simultaneously in one WebSocket feed. 
 You can subscribe to all tickers using the "\*" character. For example, to subscribe to trades for the entire US equities universe, you can use {"action":"subscribe", "params":"T.\*"} 
 You can also use a comma separated list of events + tickers to subscribe to a custom list of tickers/events, such as {"action":"subscribe", "params":"T.AAPL, Q.MSFT, AM.F, A.SPY"} 
 The maximum character limit you can insert in the subscribe message is 1MB worth of characters.

How many tickers can you subscribe to on a single Polygon WebSocket connection? 

Survivorship bias refers to the tendency to focus on the performance of existing stocks or funds without considering those that have failed. To avoid this bias, our market data includes companies that have been delisted from the exchanges and is stored as it occurred on that date. 
 
Additionally we have a Ticker Events Endpoint that displays a ticker symbol's history. It currently only tracks ticker changes, but we plan on adding additional corporate actions like mergers, acquisitions, spin-offs, etc...

What does Polygon do with delisted tickers? 

Each account comes with access to one simultaneous WebSocket connection per cluster. For example, if you have our Stocks Developer package and our Currencies package, you will have access to one stocks WebSocket connection, one crypto WebSocket connection, and one forex WebSocket connection. You can connect to as many tickers or events as you want in a single WebSocket feed. For example, you could stream AAPL trades, GM quotes, and F aggregates per minute in a single connection. 
 If you need additional stock WebSocket connections, they can be purchased for $75/month/connection.

How many Polygon WebSocket connections can I use at one time? 

Our WebSockets are only available through our paid subscriptions. If you receive a "not authorized" message, you'll need to upgrade your account to access the WebSockets. 
 You can upgrade your account in your [dashboard](https://polygon.io/dashboard/products "dashboard"). Each product has access to its own WebSocket clusters, for example, the stocks package only comes with access to the stocks cluster. To stream forex, crypto, or options data, you would need to purchase one of those packages. If you need help, please reach out to [sales@polygon.io](mailto:sales@polygon.io "sales@polygon.io")

Why am I “not authorized” when attempting to connect to Polygon’s WebSockets?

We have three different subscriptions for four types of data: US stocks, currencies (Forex + Crypto), and US options. Each subscription type has different tiers, ranging from free end-of-day data to real-time data. You can view the details of our various subscription packages on our [products page](https://polygon.io/products "products page"). 
 
You can upgrade or modify your account at any time in your [dashboard](https://polygon.io/dashboard "dashboard").

What are the different Polygon subscriptions I can use? 

We offer historical tick-level data for stocks dating back to 2004. This includes tick-level trades, NBBO (National Best Bid and Offer) quotes, and custom aggregates with a resolution of 1 minute.


How much historical data does Polygon have? 

Implied Volatility (IV) is a metric used to estimate the likelihood of changes in a security's price. It can be used to project future price moves and is used to price options contracts. IV helps quantify market sentiment and uncertainty, but it is based on price alone and not fundamentals. We use the binomial option pricing model to calculate our IV. You can learn more about Implied Volatility in our resource "[Greeks and Implied Volatility](https://polygon.io/blog/greeks-and-implied-volatility/ "Greeks and Implied Volatility")"

What is Implied Volatility (IV)?

Our [Aggregates endpoint](https://polygon.io/docs/stocks/get_v2_aggs_ticker__stocksticker__range__multiplier___timespan___from___to "Aggregates endpoint")  has a limit parameter that limits the number of base aggregates queried to create the aggregate results. The base aggregate would be the timespan used in the query. When querying minute or hourly aggregate bars, the limit parameter has a base of minutes. The maximum number of results returned is 50,000 results. This means that when querying minute bars with the maximum limit, you are querying 50,000 minutes' worth of bars. This is approximately 1.5 months' worth of minute bars. If you are querying a larger time frame, you may see gaps in the aggregate response. To avoid this, we recommend limiting any minute or hourly aggregate bar requests to 1-month time frames per query. You can read more about this process in our blog post - [Aggregate Updates](https://polygon.io/blog/aggs-api-updates/ "Aggregate Updates")


What is the function of the limit parameter in Polygon's Aggregate Endpoint?

Yes, we support every single Option trade that occurs on the US Options market. Typically, Options trading ends at 4 PM EST. However, there are a handful of ETF Options contracts that trade until 4:15 PM EST. Here is a full list of ETF Options that can be traded after 4 PM EST -
 
 
AUM, AUX, BACD, BPX, BRB, BSZ, BVZ, CDD, CITD, DBA, DBB, DBC, DBO, DBS, DIA, DJX, EEM, EFA, EUI, EUU, GAZ, GBP, GSSD, IWM, IWN, IWO, IWV, JJC, JPMD, KBE, KRE, MDY, MLPN, MNX, MOO, MSTD, NDO, NDX, NZD, OEF, OEX, OIL, PZO, QQQ, RUT, RVX, SFC, SKA, SLX, SPX, SPX (PM Expiration), SPY, SVXY, UNG, UUP, UVXY, VIIX, VIX, VIXM, VIXY, VXEEM, VXST, VXX, VXZ, XEO, XHB, XLB, XLE, XLF, XLI, XLK, XLP, XLU, XLV, XLY, XME, XRT, XSP, XSP (AM Expiration), & YUK

Does Polygon have data for any Options that are traded after 4 PM EST? 

Our aggregates “snap” the time spans to the beginning of each timespan resolution. Snapping a time parameter means changing that time parameter to include a wider range to ensure all the aggregate bars are full. We snap the ‘from’ parameter to the beginning of the resolution, and we snap the ‘to’ parameter to the end resolution. For example, minute bars begin at the top of the minute (9:30:00), hour bars begin at the top of the hour (9:00:00), daily bars begin at the beginning of the day (12:00:00 AM EST), weekly bars begin Sunday at 12:00:00 AM EST, monthly bars begin on the first day of the month and quarterly bars begin on the first day of the quarter. 
 
If you are trying to query the Open, High, Low, Close values from just the premarket times, you would need to use a ‘minute’ timespan and adjust the multiplier to 330 or 5.5 hours (4 AM - 9:30 AM). This would return one bar for the entire premarket. 
 
You can read more about this process in our blog post - [Aggregate Updates](https://polygon.io/blog/aggs-api-updates/ "Aggregate Updates")

How does Polygon treat hourly bars when querying regular trading hours (9:30 AM - 4PM EST)?

We support the entire US equities market as well as the entire US options market. Any stock or option contract traded on any of the 19 US exchanges + dark pools are supported through our platform. You can see a full list by using our [Tickers v3 endpoint](https://polygon.io/docs/stocks/get_v3_reference_tickers "Tickers v3 endpoint") to query all of the supported tickers for each asset class.
 
 
We source our forex data from a variety of institutional-level banks. You can see a full list of [supported forex pairings](https://docs.google.com/document/d/1_1SkOZN8_AMq34VRCXvkqCbxXLqb81jYndIDsBIWK3U/edit "supported forex pairings") by using our [Tickers v3 endpoint](https://polygon.io/docs/forex/get_v3_reference_tickers "Tickers v3 endpoint").
 
 
We source our crypto data from 4 of the highest volume exchanges on the market. Coinbase, Kraken, BitStamp, and Bitfinex. You can see a full list of [supported crypto pairings](https://docs.google.com/spreadsheets/d/1uKsrUoGXEBVp9Jk53MhHZTxBzJlpv2T07kGRiDjLR1c/edit#gid=0 "supported crypto pairings") by using our [Tickers v3 endpoint](https://polygon.io/docs/crypto/get_v3_reference_tickers "Tickers v3 endpoint").

What symbols/exchanges are included in Polygon’s data?

We stream our market data exactly as we receive it. Every single trade and NBBO quote is sent in real-time through the WebSockets. As long as you can consume the data fast enough, you can consume the entire US equities universe of trades, NBBO quotes and aggregates in one WebSocket connection.
 
 
US Stocks 
Trades: Average ~2000 messages per second 
Quotes: Average ~8000 messages per second 
 
Currencies 
Quotes: Average of ~400 messages per second 
 
Crypto 
Trades: Average ~45 messages per second 
L2 Quotes: Average ~600 messages per second 
L1 Quotes: Average ~200 messages per second 
 
Options 
Trades: Average ~ 300 messages per second 
Quotes: Average ~ 300,000 messages per second 
 
It is important to keep in mind that each message can contain multiple events.

How much data is streamed through Polygon’s WebSockets?  

We pride ourselves on having some of the lowest latency in the industry. Our servers are connected directly to the US SIPs and OPRA feeds, providing the fastest access to US equities and options data. Our average latency for US stocks and options data is <20ms. For Currencies, our average latency is <200ms. Crypto has an average latency of <40ms. Latencies may vary depending on your geographical location, consumption speeds, and internet.
 
 
US Stocks 
Trades + Quotes: Mean time of <20ms 
 
Currencies 
Quotes: Mean time of <200ms 
 
Crypto 
Trades: Mean time of <40ms 
L2 Quotes: Mean time of <40ms 
L1 Quotes: Mean time of <40ms 
 
US Options 
Trades + Quotes: Mean time of <20ms

Options

18 QUESTIONS IN THIS CATEGORY:

Newsletter Sign Up

Join us on Slack

Find us on GitHub