Audit Fees API

To find what a specific public company paid its auditor for its most recent fiscal year, search the /audit-fees endpoint for that company's proxy statements and read the fee amounts inside the records array. The company is identified by its CIK on the entity object (entities.cik) or by its stock ticker (entities.ticker), for example 1318605 or TSLA for Tesla. Sort results so the most recent filing comes first, using the filing timestamp (filedAt) in descending order.

Each matching Form DEF 14A returns a records array containing one entry per disclosed fiscal year. The fiscal year of the entry is on records.year, and the amount paid to the auditor for that year sits on records.auditFees. The reporting period of the proxy itself is on periodOfReport. For the most recent year disclosed, pick the record whose records.year matches that fiscal year. Related amounts on the same record include audit-related work (records.auditRelatedFees), tax services (records.taxFees), other services (records.allOtherFees), and the combined total (records.totalFees).

To look up audit fee history for a company by its stock ticker, query the /audit-fees endpoint filtering on the ticker field of the entity (entities.ticker). The value should be the exact ticker symbol as it appears in the filing, for example AAPL or TSLA. Sort by the filing timestamp (filedAt) in descending order to walk through the company's proxy statements from the most recent backward.

Each Form DEF 14A returns a records array containing one entry per disclosed fiscal year (records.year), with the audit fees on records.auditFees and the auditor name on records.auditor. Most proxies disclose two consecutive years, so iterating through the matching filings and joining their record arrays produces the company's audit fee history. Note that some smaller filers in the dataset do not have a ticker populated on the entity object, in which case the CIK identifier (entities.cik) is the reliable alternative.

To retrieve audit fee disclosures by a company's SEC CIK number, query the /audit-fees endpoint filtering on the CIK field of the entity (entities.cik). The value should be the company's numeric CIK with leading zeros omitted, for example 1318605 for Tesla or 721994 for Lakeland Financial Corp. CIK is the most reliable identifier because it is always populated, while the stock ticker (entities.ticker) may be missing for some smaller filers.

The matching Form DEF 14A filings each return a records array with the per-year audit fee amounts (records.auditFees), the auditor name (records.auditor), and the fiscal year of each entry (records.year). Sorting by the filing timestamp (filedAt) in descending order returns the most recent proxy first, which carries the latest two disclosed fiscal years.

To pull a single Form DEF 14A's fee disclosure by its accession number, query the /audit-fees endpoint filtering on the accession number field (accessionNo). The value should be the SEC accession number with dashes intact, for example 0001193125-16-543341. Because accession numbers are unique per filing, the response contains a single record under data.

That record carries the filing metadata on the top-level object (formType, filedAt, periodOfReport) and the auditor's compensation on the records array. Each entry in records corresponds to one disclosed fiscal year (records.year) with the auditor's name (records.auditor) and the per-category amounts on records.auditFees, records.auditRelatedFees, records.taxFees, records.allOtherFees, and records.totalFees.

To find every proxy statement that disclosed audit fees during a particular date range, query the /audit-fees endpoint filtering on the filing timestamp (filedAt) and restricting it to fall between the start and end of the window. For example, the value of filedAt should fall between 2024-01-01 and 2024-12-31 to retrieve everything filed during calendar year 2024.

Sort results by filedAt (ascending walks the window chronologically, descending starts from the most recent). The response is capped at 50 records per page; to walk a larger window, paginate by stepping the from offset up to a maximum of 10000. For windows that contain more results than the offset cap can reach, switch to the monthly bulk files at /bulk/audit-fees/YEAR/YEAR-MONTH.jsonl.gz.

To identify companies that paid their auditors more than a given dollar threshold, query the /audit-fees endpoint with a numeric comparison on the per-year audit fee amount (records.auditFees). For example, set the audit fee value to be greater than 10000000 to surface the proxies disclosing audit fees above ten million dollars. The comparison is applied against the audit fee amounts inside the records array.

Sort by the filing timestamp (filedAt) in descending order to see the most recent large engagements first. Each match returns the company identity on the entity object (entities.companyName, entities.ticker, entities.cik) and the qualifying fee details inside records, including the fiscal year (records.year) and the auditor name (records.auditor). To target the combined total instead of just the core audit work, swap the comparison onto records.totalFees.

To list every Form DEF 14A filed in a particular calendar month from earliest to latest, query the /audit-fees endpoint filtering on the filing timestamp (filedAt) with the start and end of that month. For example, the value of filedAt should fall between 2024-05-01 and 2024-05-31 for May 2024. Sort results by filedAt in ascending order so the earliest filings appear first.

The response page is limited to 50 records, so for busy months that exceed 50 filings, paginate by increasing the from offset up to a maximum of 10000. As an alternative, the entire month is available in one batch at /bulk/audit-fees/YEAR/YEAR-MONTH.jsonl.gz, for example /bulk/audit-fees/2024/2024-05.jsonl.gz.

To find every audit fee record where the combined total fees exceeded a certain amount, query the /audit-fees endpoint with a numeric comparison on the total fees field inside the records array (records.totalFees). For example, the value of records.totalFees should be greater than 5000000 to return the proxies that reported total auditor compensation above five million dollars.

Sort by the filing timestamp (filedAt) to control ordering, descending for newest first. Each match returns the company on the entity object (entities.companyName, entities.cik) and the qualifying record inside records with its fiscal year (records.year), auditor (records.auditor), and the individual fee categories (records.auditFees, records.auditRelatedFees, records.taxFees, records.allOtherFees). Note that not every filing populates records.totalFees — some records leave it as null — so a strict total-fee filter naturally excludes those filings.

To find every company audited by a particular accounting firm, query the /audit-fees endpoint filtering on the auditor name inside the records array (records.auditor). The value should match the firm's name as the company disclosed it, for example PricewaterhouseCoopers LLP, Crowe LLP, KPMG, BDO, or Grant Thornton LLP. Because firm names vary slightly across filings (for example PricewaterhouseCoopers LLP, United States versus PricewaterhouseCoopers LLP), it can help to search on a partial or quoted phrase covering the variant forms.

Sort by the filing timestamp (filedAt) in descending order to see the newest engagements first. Each match returns the company identity on the entity object (entities.companyName, entities.cik, entities.ticker) and the matching engagement details inside records, including the fiscal year (records.year) and the fees billed (records.auditFees, records.totalFees).

To list the audit firms a particular company has used over time, first pull every Form DEF 14A filing for that company from the /audit-fees endpoint, identifying the company by CIK on the entity object (entities.cik) or by ticker (entities.ticker). Sort by the filing timestamp (filedAt) in ascending order so the proxies come back oldest first.

For each returned filing, read the auditor name from each entry of the records array (records.auditor). Collecting the distinct values of records.auditor across all returned filings, in filedAt order, produces the company's auditor history with the fiscal year of each engagement on records.year. For example, a single company's proxies might report Crowe LLP across multiple years, while another company's proxies might show a transition from BDO to PricewaterhouseCoopers LLP.

To filter audit fee records by industry, query the /audit-fees endpoint on the Standard Industrial Classification code of the filing entity (entities.sic). The value is the SIC code that begins the string, for example 6022 for State Commercial Banks or 2834 for Pharmaceutical Preparations. The SIC field stores the code followed by the human-readable description (for example 6022 State Commercial Banks), so a search may need to use a prefix or quoted phrase to match it.

Sort by the filing timestamp (filedAt) in descending order to see the most recent proxies in the industry first. Each match returns the company identity on the entity object (entities.companyName, entities.cik) along with the audit fee details inside records including the auditor (records.auditor) and the per-category amounts (records.auditFees, records.totalFees).

To restrict audit fee results to companies incorporated in a particular U.S. state or jurisdiction, query the /audit-fees endpoint filtering on the state of incorporation field of the entity (entities.stateOfIncorporation). The value is the two-letter state code, for example DE for Delaware, IN for Indiana, WA for Washington, or FL for Florida. For non-U.S. registrants, the value is the country name rather than a two-letter code.

Sort by the filing timestamp (filedAt) in descending order to see the most recent filings first. Each match returns the company on the entity object (entities.companyName, entities.cik, entities.ticker) along with the audit fee details inside records. To narrow further to an industry within the state, combine the state filter with a Standard Industrial Classification filter on entities.sic.

Audit fee disclosures inside a Form DEF 14A typically cover two prior fiscal years, so a proxy filed in 2024 generally reports fee amounts for fiscal years 2023 and 2022. To target a specific fiscal year regardless of when the proxy was filed, query the /audit-fees endpoint filtering on the year field inside the records array (records.year), for example 2022.

The response returns the matching filings with their records array, and the entry whose records.year equals the requested year carries the audit fee amount on records.auditFees and the auditor on records.auditor. Combine the year filter with a company identifier (entities.cik or entities.ticker) to pin the lookup to a single company, or with records.auditor to pin it to a single firm.

To find Form DEF 14A filings whose reporting period ends on a particular date, query the /audit-fees endpoint filtering on the reporting period field (periodOfReport). The value is in YYYY-MM-DD format, for example 2020-12-31 for a calendar-year-end proxy or 2014-05-22 for a fiscal-year-end of late May. The reporting period for an annual proxy normally aligns with the company's fiscal year end.

Sort by the filing timestamp (filedAt) in descending order to see the most recent filings with that reporting period first. To pull every filing whose reporting period falls inside a window (rather than on an exact date), express periodOfReport as falling between a start and an end date instead of an exact match.

To find companies whose fiscal year ends in a month other than December, query the /audit-fees endpoint filtering on the fiscal year end field of the entity (entities.fiscalYearEnd). The value is a four-digit MMDD representation of the month and day of the fiscal year end, for example 0630 for June 30, 0331 for March 31, 0930 for September 30, or 0628 for the last Saturday in June. Companies with a calendar year end carry 1231.

Sort by the filing timestamp (filedAt) in descending order to see the most recent proxies first. Each match returns the company on the entity object (entities.companyName, entities.cik) and the related audit fee disclosures inside records. Pair the fiscal year end filter with an industry filter (entities.sic) or a state filter (entities.stateOfIncorporation) to refine the population further.

To retrieve audit fee records where the tax-related fees billed by the auditor exceeded a specific amount, query the /audit-fees endpoint with a numeric comparison on the tax fees field inside the records array (records.taxFees). For example, the value of records.taxFees should be greater than 500000 to surface the engagements where tax services topped half a million dollars.

Sort by the filing timestamp (filedAt) in descending order to see the most recent ones first. Each match returns the company on the entity object (entities.companyName, entities.cik) and the qualifying record on records with the fiscal year (records.year), auditor (records.auditor), and the related fee categories (records.auditFees, records.auditRelatedFees, records.allOtherFees, records.totalFees). Note that records.taxFees is sometimes null, and those filings are naturally excluded by a numeric threshold.

To find proxy filings that paid material audit-related (assurance) fees in addition to the main audit fee, query the /audit-fees endpoint with a numeric comparison on the audit-related fees field inside the records array (records.auditRelatedFees). For example, the value of records.auditRelatedFees should be greater than 100000 to surface engagements where assurance work beyond the financial-statement audit topped one hundred thousand dollars. Audit-related fees cover assurance services that are reasonably related to the audit but not part of it.

Sort by the filing timestamp (filedAt) in descending order to see the most recent first. Each match returns the company on the entity object (entities.companyName, entities.cik) along with the qualifying record on records, including the auditor (records.auditor), the fiscal year (records.year), and the main audit fee for context (records.auditFees). To combine the comparison with a minimum main audit fee, also constrain records.auditFees.

Several fee category fields on the records array can be unreported and stored as null for a filing — most commonly records.totalFees, records.allOtherFees, records.taxFees, and records.auditRelatedFees. To filter out records where a specific category is missing, query the /audit-fees endpoint with a numeric comparison that excludes the unreported case, for example requiring that the value of records.totalFees be greater than 0. Because a missing value is null rather than zero, a strict numeric comparison naturally drops the records that are missing the field.

For stronger guarantees that every fee category is reported, combine multiple constraints so that each of the categories the analysis depends on — for example records.auditFees, records.totalFees, and records.auditor — has to be populated. The auditor name (records.auditor) is also sometimes left blank as an empty string rather than null, so a downstream filter on the returned data may need to drop records where records.auditor is empty as well.

Reconciliation has to happen on the client side because the /audit-fees endpoint exposes the four category fields (records.auditFees, records.auditRelatedFees, records.taxFees, records.allOtherFees) and the reported total (records.totalFees) as separate amounts on each entry of the records array, but does not compute the difference for you. To detect mismatches, pull the relevant filings from /audit-fees and, for each entry in each filing's records array, sum the four category amounts and compare the result with records.totalFees.

For a sweep across a large window, the bulk endpoint at /bulk/audit-fees/YEAR/YEAR-MONTH.jsonl.gz is the practical input, since iterating through every line and flagging the records where the sum and the reported total differ by more than a small tolerance scales better than paginating the search endpoint. Treat unreported categories (null values) as zero when summing, and ignore records where records.totalFees itself is null because there is nothing to reconcile against.

To download every audit fee record for a given month in one batch, use the bulk download endpoint at /bulk/audit-fees/YEAR/YEAR-MONTH.jsonl.gz, for example /bulk/audit-fees/2025/2025-02.jsonl.gz for February 2025. The endpoint returns a gzip-compressed JSON Lines file where each line is the full JSON object for one Form DEF 14A — the same shape returned by the search endpoint, with the top-level metadata (accessionNo, formType, filedAt, periodOfReport), the entity array (entities), and the records array (records).

Because the bulk file contains every filing for the month, this is the preferred path when a search window is large enough to bump up against the 10000-record pagination ceiling on the search endpoint. New filings are appended to the appropriate month's bulk file daily between 1:00 AM and 4:00 AM Eastern Time.

To discover which monthly bulk files exist and when each was last updated, fetch the index at /bulk/audit-fees/index.json. The endpoint returns a JSON array where every entry describes one monthly file, with the file path on key (for example 2025/2025-05.jsonl.gz), the last-update timestamp on updatedAt (for example 2025-05-20T06:09:44.000Z), and the file size in bytes on size.

From each entry, the path on key can be appended to the bulk prefix to fetch the actual file at /bulk/audit-fees/{key}. The index lists every available year-month combination, so iterating it identifies which months are downloadable and shows the size of each file ahead of downloading.

To keep a local copy of the audit fee dataset in sync, poll the index at /bulk/audit-fees/index.json and re-download any monthly bulk file whose updatedAt timestamp is newer than the timestamp recorded the last time it was fetched. Each entry in the index identifies one monthly file by its path on key (for example 2025/2025-05.jsonl.gz), its last-update timestamp on updatedAt, and its size in bytes on size.

New filings are added to the appropriate month's bulk file daily between 1:00 AM and 4:00 AM Eastern Time, so a once-per-day poll after 4:00 AM ET catches the freshest data. For each entry whose updatedAt advanced since the last sync, fetch the file at /bulk/audit-fees/{key} and replace the local copy. Months that have not changed since the previous poll can be skipped, keeping the sync incremental.

The /audit-fees endpoint returns at most 50 records per response — that is both the default and the maximum value for the size parameter. To collect more than 50 matching filings for a query, walk subsequent pages by increasing the starting position parameter (from) in steps equal to the page size: from=0 for the first page, from=50 for the second, from=100 for the third, and so on. The starting position is capped at a maximum of 10000, which bounds the total number of records reachable through search pagination at roughly twenty thousand per query.

For a query whose total matches exceed the pagination ceiling, the bulk path at /bulk/audit-fees/YEAR/YEAR-MONTH.jsonl.gz returns every filing for a month in one file with no per-query cap. The total number of records that match a query is reported on the response under total.value, which is useful for deciding when to switch from search to bulk.

Results from the /audit-fees endpoint are sorted by the filing timestamp (filedAt) in descending order by default, putting the most recent proxies first. To get the oldest disclosures first instead, set the sort to filedAt in ascending order. Combined with pagination using the starting position parameter (from), the response walks the matched filings chronologically from earliest to latest.

Alternatively, to order by the reporting period rather than the filing timestamp, sort on periodOfReport in ascending order — this orders by the fiscal year covered by the proxy rather than by when the proxy was lodged.

To track year-over-year changes in audit fees for a single company, query the /audit-fees endpoint filtering on the company identifier on the entity object (entities.cik or entities.ticker) and sort by the filing timestamp (filedAt) in ascending order so the proxies come back oldest first. Each Form DEF 14A's records array typically carries two consecutive fiscal years, each with the year on records.year and the audit fee amount on records.auditFees.

Iterating across the returned filings and joining the records arrays produces a per-year series — for example, a series for Lakeland Financial might show records.auditFees of 429500 for fiscal 2019 and 443250 for fiscal 2020, drawn from a single proxy filing. The same logic applies to comparing the other fee categories (records.auditRelatedFees, records.taxFees, records.allOtherFees, records.totalFees) year over year. When successive proxies overlap on a fiscal year, prefer the value from the more recent filing in case the prior year's number was restated.

To detect when a company switched auditors between two consecutive proxy years, query the /audit-fees endpoint filtering on the company's identifier on the entity object (entities.cik or entities.ticker) and sort by the filing timestamp (filedAt) in descending order. Read the auditor name from each entry of the records array (records.auditor) on the two most recent filings and compare them — a switch is when the values differ.

Because a single proxy's records array usually carries two years (records.year) with the auditor name on records.auditor, a transition can also surface inside one filing: the prior fiscal year may show one firm and the current year may show another. For example, comparing two consecutive proxies that move from BDO to PricewaterhouseCoopers LLP indicates a switch in between. Be tolerant of minor name variants when comparing (for example PricewaterhouseCoopers LLP versus PricewaterhouseCoopers LLP, United States).

To rank the largest audit engagements by fees paid in a particular fiscal year, query the /audit-fees endpoint filtering on the year inside the records array (records.year), for example the value of records.year should be 2024. Sort by the audit fee amount (records.auditFees) in descending order to surface the largest engagements first, or by records.totalFees to rank on total auditor compensation rather than only the core audit work.

Because the search endpoint caps responses at 50 records per page with a maximum starting position of 10000, building a full ranking for a high-volume year is better done from the monthly bulk files at /bulk/audit-fees/YEAR/YEAR-MONTH.jsonl.gz. Concatenate the twelve files covering the year, extract every record whose records.year matches the target fiscal year, and sort the resulting list locally by records.auditFees or records.totalFees in descending order. The company identity travels on the entity object (entities.companyName, entities.cik, entities.ticker) and the auditor name on records.auditor.

To compute the average audit fee for companies in a particular industry sector, query the /audit-fees endpoint filtering on the Standard Industrial Classification code of the entity (entities.sic), for example 6022 for State Commercial Banks or 2834 for Pharmaceutical Preparations. The SIC field stores the code followed by the human-readable description, so matching on the leading code prefix surfaces every filer in the industry.

For each returned filing, read the audit fee amount from each entry of the records array (records.auditFees), optionally restricting to a single fiscal year on records.year so that the average compares like with like. The arithmetic mean of those values is the industry average. When the population for the industry exceeds what search pagination can return (a starting position cap of 10000), pull the monthly bulk files at /bulk/audit-fees/YEAR/YEAR-MONTH.jsonl.gz for the relevant period, filter locally on the SIC prefix in entities.sic, and aggregate records.auditFees across the filtered set.

The /audit-fees endpoint accepts compound criteria in a single query, so a date window, an industry filter, and a fee threshold can be combined into one request. Restrict the filing timestamp (filedAt) to fall between the start and end of the date window — for example between 2023-01-01 and 2023-12-31 — and require the Standard Industrial Classification code of the entity (entities.sic) to match the target industry, for example 6022 for State Commercial Banks. Add a numeric comparison on the audit fee amount inside the records array (records.auditFees) — for example greater than 500000 — to enforce the fee threshold. All three constraints must hold on the same filing for it to match.

Sort by the filing timestamp (filedAt) in descending order to walk through the most recent matches first. Any other field on the filing or its records array can be added as a further criterion, for example narrowing to one state of incorporation on entities.stateOfIncorporation or to a particular auditor on records.auditor.

When a company changes auditors during a fiscal year, the Form DEF 14A discloses fees paid to each firm separately, and the /audit-fees endpoint represents this by emitting one entry in the records array per auditor. Two entries in records that share the same value of records.year but carry different values of records.auditor indicate that the company paid more than one firm for that fiscal year. The search endpoint does not group records by year on the server, so the detection happens on the client after pulling the filings.

A practical approach is to query the /audit-fees endpoint for the population of interest — for example by date window on the filing timestamp (filedAt), by industry on the entity (entities.sic), or by a single company on entities.cik — and for each returned filing, group the entries in records by records.year and flag any year that produces more than one distinct records.auditor value. The two auditors involved in the transition are then the distinct records.auditor values on those entries, and the corresponding fees paid to each are on records.auditFees. For a broad sweep, the monthly bulk files at /bulk/audit-fees/YEAR/YEAR-MONTH.jsonl.gz give every filing in a month in one batch, which is the practical input when scanning a long window for mid-year auditor changes.