# Outstanding Shares & Public Float Data > Access the number and class of current and historical outstanding shares of any publicly traded company listed on US stock markets. The most recently reported public float as well as historical float data is also included. Source: https://sec-api.io/docs/outstanding-shares-float-api The API provides the number of outstanding shares for each class of securities and the public float for publicly traded companies listed on US stock markets. It includes both the most recent outstanding shares and float as well as historical information. Historical data is often used for backtesting trading strategies or for modelling company valuations. If a company has multiple share classes, the API returns the outstanding share count for each class. The database is searchable by ticker or CIK of a company. Example: Outstanding Shares & Public Float Data Response ```json { "tickers": ["GOOGL", "GOOG"], "cik": "1652044", "reportedAt": "2023-02-02T21:23:45-05:00", "periodOfReport": "2022-12-31", "float": { "outstandingShares": [ { "period": "2023-01-26", "shareClass": "CommonClassA", "value": 5956000000 }, { "period": "2023-01-26", "shareClass": "CommonClassB", "value": 883000000 }, { "period": "2023-01-26", "shareClass": "CapitalClassC", "value": 5968000000 } ], "publicFloat": [ { "period": "2022-06-30", "shareClass": "", "value": 1256100000000 } ] }, "sourceFilingAccessionNo": "0001652044-23-000016", "id": "4a29432e1345e30a01e4aa10a2b57b62" } ``` The share count per class, public float and reference period is derived from the latest quarterly and annual reports, including data from both domestic and foreign EDGAR filers. The data excludes any shares issued or bought back after the latest quarterly or annual report. Dataset size: Outstanding shares and public float of all listed and unlisted companies on US stock markets. Data update frequency: New data is available within 300 milliseconds after a new filing is published. Data history: From 2011 to present. Survivorship bias free: Yes. The database includes all outstanding shares and public float data of companies listed and unlisted on US stock markets. ## API Endpoint To search and retrieve current and historical outstanding shares and float data, send an HTTP `GET` request with the ticker or CIK of a company to the following API endpoint: https://api.sec-api.io/float Supported HTTP methods: `GET` Response content type: `JSON` ### Authentication To authenticate your API requests, use the API key available in your [user profile](https://sec-api.io/login). You can utilize your API key in one of two ways. Choose the method that best fits your implementation: - **Authorization Header:** Include your API key as an `Authorization` header in your `GET` requests. For instance, before sending a `GET` request to `https://api.sec-api.io/float`, ensure the header is set as follows: `Authorization: YOUR_API_KEY`. - **Query Parameter:** Alternatively, append your API key directly to the URL as a query parameter. For example, when making `GET` requests, use the URL `https://api.sec-api.io/float?token=YOUR_API_KEY` instead of the base endpoint. ## Request Parameters Outstanding shares and float data can be retrieved by providing either the ticker or CIK of a company as a query parameter to the API endpoint. The following parameters are supported: - `ticker` (string) - The ticker of the company. Example: `AAPL` - `cik` (string) - The CIK of the company. Remove leading zeros. Example: `1067983` (valid), `0001067983` (invalid) ### Request Examples - `GET` https://api.sec-api.io/float?ticker=AAPL - `GET` https://api.sec-api.io/float?cik=1318605 ## Response Structure **Response type:** JSON - `data` (array) - Array of float data items. - `id` (string) - Unique ID of float data item. Example: `f7611b5b0ddb134ae6d4701043eb0e9d` - `tickers` (array of strings) - Tickers the float data applies to. Includes a single ticker if one share class is available. Includes multiples tickers if multiple share classes are available. Examples: `["AMD"]`, `["GOOG", "GOOGL"]`, `["CAT", "CAT23", "CAT35"]` - `cik` (string) - CIK of the filer, without trailing zeros. Example: `18230` - `reportedAt` (datetime) - The datetime the filing and float data was published. Example: `2023-02-15T10:27:56-05:00` - `periodOfReport` (date) - The period of the report the float data applies to. Example: `2022-12-31` - `float` (object) - Float data for the reporting period. - `outstandingShares` (array) - Array of outstanding shares objects. Each object includes the number of outstanding shares per share class and the period the information applies to. - `period` (date) - Period the information applies to. Example: `2022-12-31` - `shareClass` (string) - Share class (if reported). Example: `CommonClassA`, `CapitalClassC` - `value` (integer) - Number of outstanding shares per share class. Example: `1372751831` - `publicFloat` (array) - Array of public float objects (if any). Each object includes the disclosed dollar amount of the public float and the period the information applies to. - `period` (date) - Period the information applies to. Example: `2022-12-31` - `shareClass` (string) - Share class (if reported). Example: `CommonClassA`, `CapitalClassC` - `value` (integer) - Public float in US dollar. Example: `367009000000` - `sourceFilingAccessionNo` (string) - The accession number of the filing the float data was reported in. Example: `0000018230-23-000011` - `total` (object) - Query statistic - `value` (integer) - The number of float data items matching your query. ### Response Examples **Request:** `GET` https://api.sec-api.io/float?ticker=GOOG **Response:** JSON ```json { "data": [ { "tickers": ["GOOGL", "GOOG"], "cik": "1652044", "reportedAt": "2023-02-02T21:23:45-05:00", "periodOfReport": "2022-12-31", "float": { "outstandingShares": [ { "period": "2023-01-26", "shareClass": "CommonClassA", "value": 5956000000 }, { "period": "2023-01-26", "shareClass": "CommonClassB", "value": 883000000 }, { "period": "2023-01-26", "shareClass": "CapitalClassC", "value": 5968000000 } ], "publicFloat": [ { "period": "2022-06-30", "shareClass": "", "value": 1256100000000 } ] }, "sourceFilingAccessionNo": "0001652044-23-000016", "id": "4a29432e1345e30a01e4aa10a2b57b62" }, { "id": "f027daeb28740f5c0e21686ea16285b8", "tickers": [ "GOOGL", "GOOG" ], "cik": "1652044", "float": { "outstandingShares": [ { "period": "2022-10-18", "shareClass": "CommonClassA", "value": 5973000000 }, { "period": "2022-10-18", "shareClass": "CommonClassB", "value": 884000000 }, { "period": "2022-10-18", "shareClass": "CapitalClassC", "value": 6086000000 } ], "publicFloat": [] }, "reportedAt": "2022-10-25T21:32:59-04:00", "periodOfReport": "2022-09-30", "sourceFilingAccessionNo": "0001652044-22-000090" }, { "id": "a269f5d0b63b69a2e6a820cb7ad7c85d", "tickers": [ "GOOGL", "GOOG" ], "cik": "1652044", "float": { "outstandingShares": [ { "period": "2022-07-22", "shareClass": "CommonClassA", "value": 5996000000 }, { "period": "2022-07-22", "shareClass": "CommonClassB", "value": 885000000 }, { "period": "2022-07-22", "shareClass": "CapitalClassC", "value": 6163000000 } ], "publicFloat": [] }, "reportedAt": "2022-07-26T19:29:36-04:00", "periodOfReport": "2022-06-30", "sourceFilingAccessionNo": "0001652044-22-000071" } ... more results ], "total": { "value": 33, "relation": "eq" } } ``` **Request:** `GET` https://api.sec-api.io/float?cik=18230 **Response:** JSON ```json { "data": [ { "id": "6a472c6d18dd0234877282fef2aa574b", "tickers": [ "CAT", "CAT23", "CAT35" ], "cik": "18230", "float": { "outstandingShares": [ { "period": "2022-12-31", "shareClass": "", "value": 516345490 } ], "publicFloat": [ { "period": "2022-06-30", "shareClass": "", "value": 94700000000 } ] }, "reportedAt": "2023-02-15T10:27:56-05:00", "periodOfReport": "2022-12-31", "sourceFilingAccessionNo": "0000018230-23-000011" }, { "id": "0ca9ccf7834eda89f3efc2c25331716b", "tickers": [ "CAT", "CAT23", "CAT35" ], "cik": "18230", "float": { "outstandingShares": [ { "period": "2022-09-30", "shareClass": "", "value": 520409355 } ], "publicFloat": [] }, "reportedAt": "2022-11-02T10:37:08-04:00", "periodOfReport": "2022-09-30", "sourceFilingAccessionNo": "0000018230-22-000223" } ... more results ], "total": { "value": 47, "relation": "eq" } } ``` ## FAQ Common questions about querying the Outstanding Shares & Public Float Data API, the response shape, and the bulk archives. ### How do I look up the current number of shares outstanding for a public company by its ticker symbol? To get the current shares outstanding for a publicly traded company, query the `/float` endpoint with the company's ticker (for example `AAPL`). The endpoint returns an array of float records ordered from most recent backwards, so the first entry in the response represents the most recently reported share count. Each record holds the share count for each share class inside the outstanding-shares array on the float object (`data[].float.outstandingShares[].value`), along with the as-of date that figure applies to (`data[].float.outstandingShares[].period`). The tickers the record applies to are listed on `data[].tickers` and the issuer's CIK is on `data[].cik`. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How do I retrieve outstanding shares and public float data for a company using its CIK instead of its ticker? To pull share data by CIK rather than ticker, query the `/float` endpoint with the company's CIK as the lookup key (for example `1318605` for Tesla). The CIK must be supplied without any leading zeros — a value copied from EDGAR like `0001318605` will not match, but `1318605` will. The response is the same shape as a ticker lookup: an array of float records where each entry contains the issuer's CIK (`data[].cik`), the tickers the record covers (`data[].tickers`), and the per-share-class outstanding-share figures (`data[].float.outstandingShares`). ```bash https://api.sec-api.io/float?cik=1318605&token=YOUR_API_KEY ``` ### How do I authenticate my requests to pull share count data without exposing my API key in the URL? To keep the API key out of the request URL when calling `/float`, send it in the `Authorization` request header instead of as a `token` query parameter. The header value is the raw API key (no `Bearer` prefix) and is read on every request to the endpoint. Using the header form keeps the key out of server access logs, browser history, and any URL-based telemetry that would otherwise capture a `?token=` parameter. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How do I get the historical time series of shares outstanding for a company so I can backtest a trading strategy? To assemble a historical time series of shares outstanding for backtesting, query the `/float` endpoint with the company's ticker or CIK. The endpoint returns every historical float record it holds for that issuer in the `data` array, with one entry per source filing going back to 2011. Each entry exposes the as-of date of the share count (`data[].float.outstandingShares[].period`), the share count itself (`data[].float.outstandingShares[].value`), the share class (`data[].float.outstandingShares[].shareClass`), and the fiscal period the underlying filing covers (`data[].periodOfReport`). Sorting the entries by `periodOfReport` produces the chronological series you can join against historical prices. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How do I see the share count broken out by each class of stock for a company that has multiple share classes? To see share counts broken out per class for a multi-class issuer, query the `/float` endpoint with the company's ticker or CIK. The per-class breakdown is in the outstanding-shares array on each record (`data[].float.outstandingShares`), with one element per share class reported in the filing. Each element identifies the class on `data[].float.outstandingShares[].shareClass` — for example `CommonClassA`, `CommonClassB`, or `CapitalClassC` for Alphabet — and gives that class's count on `data[].float.outstandingShares[].value` as of the date in `data[].float.outstandingShares[].period`. When an issuer reports only a single class, the `shareClass` field is an empty string. ```bash https://api.sec-api.io/float?ticker=GOOG&token=YOUR_API_KEY ``` ### How do I find the latest reported public float in US dollars for a given company? To get a company's most recently disclosed public float in US dollars, query the `/float` endpoint with the issuer's ticker or CIK and look at the public-float array on each record (`data[].float.publicFloat`). The dollar amount is on `data[].float.publicFloat[].value` and the date it applies to is on `data[].float.publicFloat[].period`. Because public float is typically only disclosed once a year on the cover page of the annual report, the latest figure is the entry on the record with the largest `data[].periodOfReport` whose `data[].float.publicFloat` array is non-empty. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How do I get the most recent shares-outstanding figure when the API returns many historical entries? To pick the most recent share count out of a long history returned by `/float`, sort the records by their reporting timestamp (`data[].reportedAt`) or by their fiscal period end (`data[].periodOfReport`) in descending order and take the first item. Both timestamps are ISO-formatted, so a lexicographic sort matches a chronological one. The selected record's outstanding-share figures live on `data[].float.outstandingShares[].value`, with the cover-page as-of date on `data[].float.outstandingShares[].period`, which is usually a few weeks after `periodOfReport`. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How do I link a share count record back to the original SEC filing it was extracted from? Each record returned by `/float` carries the accession number of the underlying SEC filing on `data[].sourceFilingAccessionNo` (for example `0001652044-23-000016`). The accession number uniquely identifies the 10-K, 10-Q, or other periodic report that the share count and public float were parsed from. That accession number can be combined with the issuer's CIK (`data[].cik`) to construct the EDGAR document URL, or passed to the `/full-text-search`, `/extractor`, or other sec-api endpoints that accept an accession number to retrieve the full filing. ```bash https://api.sec-api.io/float?ticker=GOOG&token=YOUR_API_KEY ``` ### How do I figure out the as-of date that a particular outstanding-share number actually applies to (vs. when it was reported)? Inside each `/float` record, the as-of date of the share count is on the period field of each outstanding-shares element (`data[].float.outstandingShares[].period`). That date is taken from the cover page of the underlying filing and corresponds to the date the issuer's transfer agent ran the count, which is often a few days or weeks before the filing was submitted. The separate `data[].reportedAt` timestamp captures when the filing itself was published on EDGAR, and `data[].periodOfReport` captures the fiscal period end the filing covers. For most quarterly and annual reports, `period` falls between `periodOfReport` and `reportedAt`. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How do I handle companies like Alphabet that trade under multiple tickers when looking up their share data? For an issuer that trades under several tickers — Alphabet's `GOOGL` and `GOOG`, or Caterpillar's `CAT`, `CAT23`, and `CAT35` — the `/float` endpoint returns the same record set regardless of which ticker you query. All tickers tied to the filing are listed in `data[].tickers`, so a single lookup by any one of them is sufficient to pull the complete share-class breakdown. Alternatively, query by the issuer's CIK (`data[].cik`), which is invariant across share classes. The CIK is the most reliable key when you want to de-duplicate records across tickers in a watchlist. ```bash https://api.sec-api.io/float?ticker=GOOGL&token=YOUR_API_KEY ``` ### How do I detect when a company has issued new shares or done a buyback between two reporting periods? To detect issuance or buyback activity between two reporting periods, pull the share history from the `/float` endpoint and compare the share counts (`data[].float.outstandingShares[].value`) on two consecutive entries, matched by share class (`data[].float.outstandingShares[].shareClass`). A positive difference indicates net issuance over the interval; a negative difference indicates a net buyback. For a clean comparison, line up entries on the cover-page as-of date (`data[].float.outstandingShares[].period`) or the fiscal period end (`data[].periodOfReport`), and exclude class boundaries by diffing within the same `shareClass` value. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How do I quickly check whether a company reports a public float number at all in its filings? Each record returned by `/float` carries a public-float array on `data[].float.publicFloat`. A record where this array is empty means the underlying filing did not disclose a public-float figure — this is the norm for quarterly reports and for many issuers whose filings are exempt from the public-float disclosure. To check whether a company ever reports public float, query `/float` with its ticker or CIK and inspect each record in the `data` array: a non-empty `data[].float.publicFloat` confirms the filing carries a dollar amount on `data[].float.publicFloat[].value`. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How do I get share counts for unlisted or delisted US companies, not just actively traded ones? The `/float` endpoint covers every company that has filed quarterly or annual reports with the SEC, including unlisted issuers and companies that have since been delisted. The dataset is survivorship-bias-free, so historical records for delisted issuers remain queryable. Because the ticker may no longer be active, lookup by CIK on the `cik` parameter is the dependable key for these issuers. Each record still exposes the historical tickers the filing referenced on `data[].tickers`. ```bash https://api.sec-api.io/float?cik=1067983&token=YOUR_API_KEY ``` ### How do I pull share-count history going back to the early 2010s for a long-horizon backtest? The `/float` endpoint exposes share-count history going back to 2011, so a single query by ticker or CIK returns the full record set covering more than a decade of filings. Each record in the `data` array represents one quarterly or annual report, with the share count on `data[].float.outstandingShares[].value` and the as-of date on `data[].float.outstandingShares[].period`. For a long-horizon backtest, iterate over the returned records sorted by `data[].periodOfReport` ascending to build a continuous quarterly series from the earliest available filing forward. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How far behind real time is the share-count data after a company files its quarterly or annual report? New share-count and public-float records become available through the `/float` endpoint within 300 milliseconds of the underlying filing being published on EDGAR. That latency covers parsing the cover page of the new 10-K or 10-Q, extracting the outstanding-shares and public-float figures, and indexing the record so it appears in subsequent queries. In practice this means a fresh record with the latest `data[].reportedAt` timestamp is queryable almost immediately after the filing hits EDGAR. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How do I compute the float-to-shares-outstanding ratio to estimate the percentage of shares freely tradable? Public float is reported in US dollars on `data[].float.publicFloat[].value`, while shares outstanding are reported as a share count on `data[].float.outstandingShares[].value`. To compare the two, divide the dollar float by the share price on the matching `data[].float.publicFloat[].period` to convert it to a share count, then divide that result by the total outstanding-share count for the same period. Pull the inputs from a single `/float` call by ticker or CIK, match a public-float entry to the outstanding-shares entry whose `period` is closest (typically the prior June 30 cover-page snapshot for the annual filing), and source the share price for the matching date from a separate price feed. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How do I retrieve the share count as of the fiscal period end vs. as of a more recent date the filing reports? A single `/float` record carries two distinct dates: the fiscal period end on `data[].periodOfReport` (for example `2022-12-31` for a calendar-year 10-K) and the cover-page as-of date for the share count on `data[].float.outstandingShares[].period` (typically a few weeks later, such as `2023-02-01`). The two figures sit on the same record because the SEC requires issuers to disclose the share count as of a recent date on the cover page rather than as of the fiscal period end. Use `periodOfReport` when you need the share count aligned with the financial statements, and `outstandingShares[].period` when you need the most accurate share count the filing actually disclosed. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How do I find the public-float value used to determine a company's filer status (large accelerated, accelerated, smaller reporting)? Filer status is determined by the public float as of the last business day of the issuer's second fiscal quarter, which is the figure disclosed on the cover page of the subsequent annual report. The `/float` endpoint exposes that value on the public-float array of the annual-report record (`data[].float.publicFloat[].value`), with the qualifying date on `data[].float.publicFloat[].period`. To find it, query `/float` with the issuer's ticker or CIK, locate the record whose `data[].periodOfReport` matches the fiscal year end, and read the dollar amount whose `period` falls on the second-quarter cutoff (for example `2022-06-30` for a calendar-year filer). ```bash https://api.sec-api.io/float?ticker=CAT&token=YOUR_API_KEY ``` ### How do I get a count of how many share-count records exist for a given company across all its filings? The `/float` endpoint returns a `total` object alongside the `data` array, and the count of records matching the query is on `total.value`. For a single-issuer lookup by ticker or CIK, that number is the count of float records held for the company across all of its periodic filings. The `total.value` figure is the full match count even when the `data` array is paginated, so it can be read directly without scanning every record. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How do I retrieve only the most recent quarterly share-count update for a ticker rather than the full history? To retrieve only the most recent record from the `/float` endpoint, query by ticker or CIK, sort the `data` array by `data[].reportedAt` descending, and take the first element. That entry corresponds to the latest quarterly or annual filing the issuer published. The selected record exposes the share count on `data[].float.outstandingShares[].value` as of `data[].float.outstandingShares[].period`, the underlying accession number on `data[].sourceFilingAccessionNo`, and the fiscal period covered on `data[].periodOfReport`. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How do I look up share data for a foreign private issuer that files annual reports on US markets? The `/float` endpoint covers both domestic and foreign EDGAR filers, so a foreign private issuer that files 20-F or 40-F annual reports is queryable by the same ticker or CIK lookup used for US filers. The response shape is identical: a `data` array of float records with per-class share counts on `data[].float.outstandingShares` and public float on `data[].float.publicFloat`. If the issuer's US ticker is unfamiliar, the CIK lookup on the `cik` parameter is the safer key because it is constant across exchange listings. ```bash https://api.sec-api.io/float?ticker=TM&token=YOUR_API_KEY ``` ### How do I aggregate total shares outstanding across all classes to get a single fully-diluted-style share count? To produce a single aggregate share count for a multi-class issuer, query `/float` with the company's ticker or CIK and sum the per-class values on `data[].float.outstandingShares[].value` for the entries that share the same `data[].float.outstandingShares[].period` within a single record. Each share class — `CommonClassA`, `CommonClassB`, `CapitalClassC` and so on — contributes one entry, and they are reported as of the same cover-page date within a given filing. Note that this aggregate counts every class equally on a one-share-equals-one-share basis. Conversion ratios between super-voting and economic classes are not part of the `/float` response. ```bash https://api.sec-api.io/float?ticker=GOOGL&token=YOUR_API_KEY ``` ### How do I detect a stock split by examining the share-count history? A stock split shows up in the `/float` history as a large step-change in `data[].float.outstandingShares[].value` between two adjacent records of the same share class, with no corresponding capital-raising event. A 3-for-1 split, for example, roughly triples the share count from one `data[].float.outstandingShares[].period` to the next. To confirm the move is a split rather than an issuance, cross-check the ratio against the price ratio for the same dates from an external price source — a split moves shares and price in inverse proportion, while a true issuance does not. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How do I find the public float as of mid-year (the second-quarter cutoff) for a list of tickers? To collect mid-year public-float values for a list of tickers, query the `/float` endpoint once per ticker and filter the public-float array on each record so that `data[].float.publicFloat[].period` falls on June 30 of the year you care about. The corresponding dollar amount is on `data[].float.publicFloat[].value`. For calendar-year filers the second-quarter cutoff is June 30, but issuers with non-calendar fiscal years report their float as of a different mid-fiscal-year date, so the filter should be applied per issuer rather than assuming `YYYY-06-30` globally. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How do I get share data for newly IPO'd companies whose first 10-Q has just been filed? Share data for a newly IPO'd company becomes queryable on the `/float` endpoint within 300 milliseconds of the first quarterly or annual report appearing on EDGAR. Until that first periodic report is filed, the company has no `/float` record, since the dataset is sourced from the cover pages of 10-K and 10-Q filings rather than from the S-1 itself. Once the first 10-Q is published, a lookup by ticker or CIK returns a single record whose `data[].float.outstandingShares[].value` reflects the post-IPO share count, with `data[].periodOfReport` set to the fiscal quarter end the filing covers. ```bash https://api.sec-api.io/float?ticker=ARM&token=YOUR_API_KEY ``` ### How do I handle a CIK with leading zeros that I copied from EDGAR when calling the API? The `/float` endpoint expects the CIK without any leading zeros, so a value like `0001067983` copied from EDGAR will not match — strip the leading zeros and supply `1067983` instead. The same rule applies to every other CIK-keyed sec-api endpoint. The CIK returned on `data[].cik` in the response is also presented without leading zeros, so values can be round-tripped through the API without reformatting. ```bash https://api.sec-api.io/float?cik=1067983&token=YOUR_API_KEY ``` ### How do I build a watchlist screener that flags companies whose share count has grown more than 10% year over year? For each ticker on the watchlist, query the `/float` endpoint by ticker or CIK and pair up records whose `data[].periodOfReport` values are roughly twelve months apart. The year-over-year change is the ratio of the later `data[].float.outstandingShares[].value` to the earlier one for the same `data[].float.outstandingShares[].shareClass` — a value above 1.10 flags the issuer for the screener. When an issuer has multiple share classes, run the comparison per class to avoid mixing dilution across `CommonClassA`, `CommonClassB`, and similar entries, or sum the values across all classes for each period first and compare the totals. ```bash https://api.sec-api.io/float?ticker=AAPL&token=YOUR_API_KEY ``` ### How do I deduplicate or cache share-count records so I do not re-process the same one across repeated API calls? Use the stable record identifier on each float item (`data[].id`) as the deduplication key when caching responses from the `/float` endpoint. Every share-count record carries a unique id such as `4a29432e1345e30a01e4aa10a2b57b62` that does not change across repeated calls, so a local cache or database keyed on that id will recognise a record you have already seen and skip re-processing it. When the same id appears in a later response, the underlying record is the same one you stored before and can be passed over. If you also want to cross-check against the underlying filing, pair the id with the source filing accession number (`data[].sourceFilingAccessionNo`) and the fiscal period (`data[].periodOfReport`), both of which are stable for a given filing. ```bash https://api.sec-api.io/float?ticker=GOOG&token=YOUR_API_KEY ``` ### How do I detect when a company introduces a brand-new share class or retires an existing one over time? To detect share-class changes over time, query the `/float` endpoint by ticker or CIK and compare the set of class labels on `data[].float.outstandingShares[].shareClass` across successive records for the same issuer. Lining up records by `data[].periodOfReport` from oldest to newest, a label that first appears in one record after being absent in the prior one signals a newly introduced class, and a label that drops out and never returns signals a retired one. When running the comparison, treat the empty-string `shareClass` (used when the filing reports a single class without naming it) as its own value, and match labels exactly — `CommonClassA`, `CommonClassB`, and `CapitalClassC` are distinct entries even when they belong to the same issuer such as Alphabet (CIK `1652044`). ```bash https://api.sec-api.io/float?cik=1652044&token=YOUR_API_KEY ``` ### How do I find which historical filing first established a company's current share count for a specific class of stock? To trace the current share count for a specific class back to the filing that first reported it, query the `/float` endpoint by ticker or CIK and read the most recent `data[].float.outstandingShares[].value` for the target `data[].float.outstandingShares[].shareClass`. That value is the current count for that class. Then scan the historical records for the same issuer, keeping only the outstanding-shares entries whose `shareClass` matches and whose `value` equals the current count, and pick the one with the earliest `data[].reportedAt`. The accession number on `data[].sourceFilingAccessionNo` for that record identifies the filing — for example a 10-Q such as `0001652044-22-000071` — that first established the share count the issuer is still reporting today. ```bash https://api.sec-api.io/float?ticker=GOOGL&token=YOUR_API_KEY ```