# Audit Fees API

> Access all audit fees disclosed in Form DEF14A on SEC EDGAR. Search and filter audit fee data by company details, date range, fee amounts, and auditor information. Includes audit fees, audit-related fees, tax fees, and other fees from 2001 to present.

Source: https://sec-api.io/docs/audit-fees-api

The Audit Fees API shows the fees that public companies pay their independent auditors, per fiscal year and auditor. The data covers fiscal years from 2002 to the present. It includes companies that were later delisted or no longer exist, such as Bear Stearns and Wachovia, so it is free of survivorship bias. For each fiscal year, a record contains the auditor and the audit, audit-related, tax, other and total fees. It also contains the ticker, CIK, industry (SIC code), state of incorporation and fiscal year end of the company. Search queries on any field return the matching records in JSON format through one API endpoint. Bulk download files contain the complete dataset.

Data sample · Audit fees

| Filed at | Ticker | Company | Fiscal year | Auditor | Audit fees | Audit-related fees | Tax fees | All other fees | Total fees | CIK | Accession no. |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 2026-05-12 | NVDA | NVIDIA CORP (Filer) | 2026 | PwC | $10,166,400.00 | $1,716,820.00 | $1,076,103.00 | $401,999.00 | $13,361,322.00 | 1045810 | 0001045810-26-000036 |
| 2026-05-12 | NVDA | NVIDIA CORP (Filer) | 2025 | PwC | $8,067,106.00 | $724,806.00 | $856,439.00 | $354,000.00 | $10,002,351.00 | 1045810 | 0001045810-26-000036 |
| 2026-04-23 | WMT | Walmart Inc. (Filer) | 2026 | EY | $44,712,000.00 | $1,335,000.00 | – | $24,000.00 | $46,071,000.00 | 104169 | 0001193125-26-173673 |
| 2026-04-23 | WMT | Walmart Inc. (Filer) | 2025 | EY | $36,306,000.00 | $1,586,000.00 | – | $24,000.00 | $37,916,000.00 | 104169 | 0001193125-26-173673 |
| 2026-04-16 | META | Meta Platforms, Inc. (Filer) | 2025 | Ernst & Young LLP | $25,942,000.00 | $7,040,000.00 | $8,379,000.00 | $2,000.00 | $41,363,000.00 | 1326801 | 0001628280-26-025532 |
| 2026-04-16 | META | Meta Platforms, Inc. (Filer) | 2024 | Ernst & Young LLP | $21,397,000.00 | $7,243,000.00 | $7,718,000.00 | $2,000.00 | $36,360,000.00 | 1326801 | 0001628280-26-025532 |
| 2026-04-08 | AMZN | AMAZON COM INC (Filer) | 2025 | EY | $47,260,000.00 | $11,696,965.00 | – | $300,000.00 | $59,256,965.00 | 1018724 | 0001104659-26-041026 |
| 2026-04-08 | AMZN | AMAZON COM INC (Filer) | 2024 | EY | $41,937,000.00 | $8,454,000.00 | – | $828,000.00 | $51,219,000.00 | 1018724 | 0001104659-26-041026 |
| 2026-04-08 | XOM | EXXON MOBIL CORP (Filer) | 2025 | PricewaterhouseCoopers LLP | $32,000,000.00 | $5,200,000.00 | $400,000.00 | – | $37,600,000.00 | 34088 | 0001193125-26-147614 |
| 2026-04-08 | XOM | EXXON MOBIL CORP (Filer) | 2024 | PricewaterhouseCoopers LLP | $34,800,000.00 | $4,600,000.00 | $300,000.00 | – | $39,700,000.00 | 34088 | 0001193125-26-147614 |
| 2026-04-06 | JPM | JPMORGAN CHASE & CO (Filer) | 2025 | PricewaterhouseCoopers LLP | $91,000,000.00 | $38,100,000.00 | $5,900,000.00 | – | $135,000,000.00 | 19617 | 0000019617-26-000096 |
| 2026-04-06 | JPM | JPMORGAN CHASE & CO (Filer) | 2024 | PricewaterhouseCoopers LLP | $78,500,000.00 | $36,000,000.00 | $4,500,000.00 | – | $119,000,000.00 | 19617 | 0000019617-26-000096 |
| 2026-01-08 | AAPL | Apple Inc. (Filer) | 2025 | Ernst & Young | $24,703,000.00 | $2,274,000.00 | $4,533,000.00 | $2,767,000.00 | $34,277,000.00 | 320193 | 0001308179-26-000008 |
| 2026-01-08 | AAPL | Apple Inc. (Filer) | 2024 | Ernst & Young | $22,381,000.00 | $2,418,000.00 | $3,435,000.00 | $2,037,000.00 | $30,271,000.00 | 320193 | 0001308179-26-000008 |
| 2025-10-21 | MSFT | MICROSOFT CORP (Filer) | 2025 | Deloitte & Touche | $53,880,000.00 | $19,470,000.00 | $5,105,000.00 | $10,000.00 | $78,465,000.00 | 789019 | 0001193125-25-245150 |
| 2025-10-21 | MSFT | MICROSOFT CORP (Filer) | 2024 | Deloitte & Touche | $56,280,000.00 | $18,643,000.00 | $6,334,000.00 | $10,000.00 | $81,267,000.00 | 789019 | 0001193125-25-245150 |
| 2025-09-17 | TSLA | Tesla, Inc. (Filer) | 2023 | PricewaterhouseCoopers LLP | $17,365,000.00 | $42,000.00 | $2,579,000.00 | $269,000.00 | $20,255,000.00 | 1318605 | 0001104659-25-090866 |
| 2025-09-17 | TSLA | Tesla, Inc. (Filer) | 2024 | PricewaterhouseCoopers LLP | $15,634,000.00 | $54,000.00 | $2,154,000.00 | $81,000.00 | $17,923,000.00 | 1318605 | 0001104659-25-090866 |
| 2025-05-13 | NVDA | NVIDIA CORP (Filer) | 2025 | PwC | $8,067,106.00 | $724,806.00 | $856,439.00 | $354,000.00 | $10,002,351.00 | 1045810 | 0001045810-25-000095 |
| 2025-05-13 | NVDA | NVIDIA CORP (Filer) | 2024 | PwC | $6,686,412.00 | $804,258.00 | $1,164,399.00 | $352,000.00 | $9,007,069.00 | 1045810 | 0001045810-25-000095 |

The records include the following categories of fees:

- audit fees: Fees billed for the audit of financial statements and internal control over financial reporting.
- audit-related fees: Fees for assurance and related services that are reasonably related to the audit or review of financial statements.
- tax fees: Fees for tax compliance, tax advice, and tax planning services.
- other fees: Fees for services that do not fall under audit, audit-related, or tax categories.
- total fees: The sum of all categories of fees for a given year.
- auditor: The name of the independent accounting firm that performed the audit or related services.

Each record is linked to a specific company, fiscal year, and auditor. If multiple auditors are reported, a record is created for each auditor. Audit fee data is updated in real time as new DEF 14A filings are published by the SEC and is accessible via API endpoints for both targeted queries and bulk retrieval.

Form DEF 14A, or the definitive proxy statement, is filed annually with the SEC by public companies to inform shareholders about matters requiring a vote at the annual meeting. Among others, it includes detailed disclosures on executive compensation, board structure, and fees paid to the company's independent auditors.

Dataset size:

More than 139,000 audit fee records extracted from 69,000 Form DEF 14A filings filed since 2001 to present.

Data update frequency:

New filings are indexed and searchable within 300 milliseconds of being published on EDGAR.

Survivorship bias free:

Yes, the dataset is free from survivorship bias, encompassing audit fee information from all companies and entities, including those that have been delisted or no longer operate.

## API Endpoint

### Audit Fees Search API

The Audit Fees Search API allows searching and filtering all Audit Fee information extracted from Form DEF 14A filings submitted from 2001 to present. The API accepts search queries as JSON formatted payload and returns the matching audit fee records in JSON format. The API endpoint is:

https://api.sec-api.io/audit-fees

Supported HTTP methods: `POST`

Request and response content type: `JSON`

### Audit Fees Bulk Dataset Download

The complete set of audit fee records is available for bulk download in compressed JSONL (JSON line) files (`.jsonl.gz`). Each line in a `.jsonl.gz` file represents the full content of an API response for a single Form DEF 14A filing including all extracted audit fee records in structured JSON format. The dataset is organized by filing year and month of the Form DEF 14A, using the filename format `YYYY-MM.jsonl.gz`, where `YYYY` is the year (e.g., `2024`) and `MM` is the month (e.g., `02` for February).

New filings are added daily to the bulk dataset between 1:00 AM and 4:00 AM ET.

An accompanying `index.json` file provides metadata for all available `.jsonl.gz` files, including:

- `key` (string) - The file path, e.g. `2025/2025-03.jsonl.gz`.
- `updatedAt` (date) - The last update timestamp, e.g. `2025-04-03T14:06:34.000Z`.
- `size` (integer) - The file size in bytes, e.g. `106764954`.

The `index.json` file is especially useful for programmatic access and automation, allowing to monitor updates and manage downloads at scale.

| Endpoint | Description | HTTP Method | Response Format |
| --- | --- | --- | --- |
| [/bulk/audit-fees/YEAR/YEAR-MONTH.jsonl.gz](#/bulk/audit-fees/year/year-month.jsonl.gz) | Gzip-compressed JSONL file containing all DEF 14A filings for the specified year and month. | GET | jsonl.gz |
| [/bulk/audit-fees/index.json](#/bulk/audit-fees/index.json) | JSON file containing the paths, file update times and file sizes of all jsonl.gz files of all DEF 14A data files. | GET | json |

#### Bulk Download Endpoint Examples

- `https://api.sec-api.io/bulk/audit-fees/2025/2025-02.jsonl.gz`
- `https://api.sec-api.io/bulk/audit-fees/index.json`

### Authentication

To authenticate API requests, use the API key displayed in your [user profile](https://sec-api.io/signup). Utilize the API key in one of two ways. Choose the method that best fits your use case:

- **Authorization Header:** Set the API key as an `Authorization` header. For instance, before sending a `POST` request to `https://api.sec-api.io/audit-fees`, ensure the header is set as follows: `Authorization: YOUR_API_KEY`. Do not include any prefix like `Bearer`.
- **Query Parameter:** Alternatively, append your API key directly to the URL as a query parameter. For example, when making `POST` requests, use the URL `https://api.sec-api.io/audit-fees?token=YOUR_API_KEY` instead of the base endpoint.

## Request Structure

The following request parameters are supported:

- `query` (string) - The search criteria in the format `field:value` defining the `field` to search in and the `value` to search for in this field. The search expression is written in [Lucene syntax](https://sec-api.io/resources/lucene-query-syntax-overview) and supports `AND` and `OR` operators. Examples: `cik:4568` or `filedAt:[2019-01-01 TO 2022-12-31]`.
- `from` (integer) - Pagination control to specify the starting position of the results. Max: 10000. Default: 0.
- `size` (integer) - The number of filings to be returned in one response. Default: 50. Max: 50.
- `sort` (array) - Specifies the field by which results should be sorted. By default, results are sorted by `filedAt` in descending order, starting with the most recent filings: `[{ "filedAt": { "order": "desc" } }]`

### Request Examples

Find the two most recently submitted Form DEF 14A filings with audit fees for the company with CIK `1277575`.

```json
{
  "query": "cik:1277575",
  "from": "0",
  "size": "2",
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

Retrieve the audit fee records associated with the file number `24R-00102` and sort them in descending order by the filing date.

```json
{
  "query": "entities.fileNo:24R-00102",
  "from": "0",
  "size": "50",
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

Find all audit fee records from Form DEF 14A filings filed in May 2024, sort them in descending order by the filing date, and limit the results to 5 filings.

```json
{
  "query": "filedAt:[2024-05-01 TO 2024-05-31]",
  "from": "0",
  "size": "5",
  "sort": [{"filedAt":{"order":"asc"}}]
}
```

Find the ten most recent Form DEF 14A filings reporting audit fees of more than $10,000,000.

```json
{
  "query": "auditFees > 10000000",
  "from": "0",
  "size": "10",
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

## Response Structure

When the API locates matches within the Audit Fees database, it returns a JSON response including two fields: `total` and `data`. The `value` field inside the `total` object indicates the total number of audit fee records that match the search criteria, while the `data` field contains an array of audit fee records that match the query. The maximum number of metadata objects inside the`data` array is determined by the `size` and limited to 50. Each audit fee record comprises the following fields:

- `id` (string) - System-internal unique identifier of the filing record.
- `accessionNo` (string) - Unique accession number of the Form DEF 14A filing, e.g. `0001193125-16-543341`.
- `formType` (string) - The form type of the SEC filing.
- `filedAt` (date) - The timestamp when the filing was accepted by SEC EDGAR, e.g. `2024-05-15T16:17:15-04:00`.
- `periodOfReport` (date) - The reporting period covered by this Form DEF 14A submission. Format: `YYYY-MM-DD`, e.g. `2024-06-30`. In annual reports this corresponds to the fiscal year end.
- `entities` (array of object) - Array of entities involved in the filing.
  - `cik` (string) - Central Index Key (CIK) of the reporting entity, e.g. `1021408`. This is a unique identifier assigned by the SEC to the filer. Leading zeros are omitted.
  - `ticker` (string) - The stock ticker symbol used to identify the entity, e.g. `GOOGL`.
  - `companyName` (string) - The legal name of the issuer as provided in the filing, e.g. `ALPHABET INC`.
  - `irsNo` (string) - The Internal Revenue Service (IRS) Employer Identification Number (EIN) of the reporting entity, e.g., `95-1234567`.
  - `fiscalYearEnd` (string) - The fiscal year-end of the reporting entity, represented as a four-digit month-day format, e.g. `1231` for December 31.
  - `stateOfIncorporation` (string) - The U.S. state or country where the entity is legally incorporated, represented using a two-letter state code (e.g., `DE` for Delaware) or a country name for non-U.S. entities.
  - `sic` (string) - The Standard Industrial Classification (SIC) code representing the primary industry of the entity, e.g., `7372` for Prepackaged Software.
  - `act` (string) - The regulatory act under which the entity files its reports, e.g., `1934` for the Securities Exchange Act of 1934.
  - `fileNo` (string) - Unique identifier used to reference and track filings of the same process, e.g. `020-34763`.
  - `filmNo` (string) - A unique identifier assigned by the SEC to track a specific filing, e.g., `211234567`.
- `records` (array of object) - Array of audit fee records.
  - `year` (number) - The fiscal year of the audit fee record, e.g., `2024`.
  - `auditFees` (number) - The audit fees paid to the auditor for the reporting period in USD, e.g., `2969000`.
  - `auditRelatedFees` (number) - The audit-related fees paid to the auditor for the reporting period in USD, e.g., `6000`.
  - `taxFees` (number) - The tax fees paid to the auditor for the reporting period in USD, e.g., `10000`.
  - `allOtherFees` (number) - The all other fees amount paid to the auditor for the reporting period in USD, e.g., `2000`.
  - `totalFees` (number) - The total fees paid to the auditor for the reporting period in USD, e.g., `2987000`.
  - `auditor` (string) - The name of the auditor for the reporting period, e.g., `PricewaterhouseCoopers LLP`.

### Response Example

JSON

```json
{
  "total": {
    "value": 10000,
    "relation": "gte"
  },
  "data": [
    {
      "id": "dcfe557d7b36025fb47997b38c2dc46d",
      "accessionNo": "0001193125-16-543341",
      "formType": "DEF 14A",
      "filedAt": "2016-04-15T17:09:07-04:00",
      "periodOfReport": "2016-05-31",
      "entities": [
        {
          "cik": "1318605",
          "ticker": "TSLA",
          "companyName": "TESLA MOTORS INC (Filer)",
          "irsNo": "912197729",
          "fiscalYearEnd": "1231",
          "stateOfIncorporation": "DE",
          "sic": "3711 Motor Vehicles & Passenger Car Bodies",
          "act": "34",
          "fileNo": "001-34756",
          "filmNo": "161575120"
        }
      ],
      "records": [
        {
          "year": 2014,
          "auditFees": 2969000,
          "auditRelatedFees": 6000,
          "taxFees": 10000,
          "allOtherFees": 2000,
          "totalFees": 2987000,
          "auditor": "PricewaterhouseCoopers LLP"
        },
        {
          "year": 2015,
          "auditFees": 4237000,
          "auditRelatedFees": 0,
          "taxFees": 0,
          "allOtherFees": 2000,
          "totalFees": 4239000,
          "auditor": "PricewaterhouseCoopers LLP"
        }
      ]
    },
    // cut off for brevity
  ]
}
```

### Response Structure of Bulk Download Endpoints

#### /bulk/audit-fees/YEAR/YEAR-MONTH.jsonl.gz

Decompressed JSONL Example

```jsonl
{"formType":"DEF 14A","periodOfReport": "{...}","records": "{...}","accessionNo":"0001752724-25-025892","filedAt":"2025-04-01T17:30:54-04:00","id":"dcfe557d7b36025fb47997b38c2dc46d"}
{ ... }
{ ... }
```

#### /bulk/audit-fees/index.json

index.json Example

```json
[
    {
        "key": "2025/2025-05.jsonl.gz",
        "updatedAt": "2025-05-20T06:09:44.000Z",
        "size": 4456349
    },
    {
        "key": "2025/2025-04.jsonl.gz",
        "updatedAt": "2025-05-20T06:09:44.000Z",
        "size": 106764954
    },
    // ... more files
  ]
```

## FAQ

Common questions about querying the Audit Fees API, the response shape, and the bulk archives.

### How much did a specific public company pay its auditor last year?

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`).

```json
{
  "query": "entities.cik:1318605",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I look up audit fee history for a company using its ticker symbol?

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.

```json
{
  "query": "entities.ticker:AAPL",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I retrieve audit fee disclosures by a company's SEC CIK number?

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.

```json
{
  "query": "entities.cik:721994",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I pull a single proxy statement's fee disclosure by its accession number?

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`.

```json
{
  "query": "accessionNo:\"0001193125-16-543341\"",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I find all proxy statements that disclosed audit fees during a specific date range?

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`.

```json
{
  "query": "filedAt:[2024-01-01 TO 2024-12-31]",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I identify companies that paid their auditors more than a given dollar threshold?

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`.

```json
{
  "query": "records.auditFees:>10000000",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I list all proxy statements filed in a particular month, sorted from earliest to latest?

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`.

```json
{
  "query": "filedAt:[2024-05-01 TO 2024-05-31]",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"asc"}}]
}
```

### How can I find every audit fee record where total fees exceeded a certain amount?

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.

```json
{
  "query": "records.totalFees:>5000000",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I find every company audited by a specific accounting firm such as PwC or Deloitte?

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`).

```json
{
  "query": "records.auditor:\"PricewaterhouseCoopers LLP\"",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I list which audit firms a particular company has used historically?

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`.

```json
{
  "query": "entities.cik:1318605",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"asc"}}]
}
```

### How do I filter audit fee records for companies in a specific industry such as commercial banks or pharmaceuticals?

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`).

```json
{
  "query": "entities.sic:6022*",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I restrict results to companies incorporated in a particular U.S. state or jurisdiction?

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`.

```json
{
  "query": "entities.stateOfIncorporation:DE",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I look up the audit fees a company reported for a specific fiscal year that may not match its filing year?

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.

```json
{
  "query": "records.year:2022",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I find proxy statements whose reporting period ends on a particular date?

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.

```json
{
  "query": "periodOfReport:2020-12-31",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I find companies whose fiscal year ends in a month other than December?

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.

```json
{
  "query": "entities.fiscalYearEnd:0630",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I retrieve audit fee records where the tax-related fees exceeded a specific amount?

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.

```json
{
  "query": "records.taxFees:>500000",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I find filings that paid significant audit-related (assurance) fees on top of the main audit?

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`.

```json
{
  "query": "records.auditRelatedFees:>100000",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I filter out records where one of the fee categories is missing or unreported?

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.

```json
{
  "query": "records.totalFees:>0",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How can I detect proxy statements where the total fees do not reconcile with the sum of the individual fee categories?

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.

```json
{
  "query": "records.totalFees:>0 AND records.auditFees:>0",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I download every audit fee record for a given month in one batch instead of paginating?

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.

```bash
https://api.sec-api.io/bulk/audit-fees/2025/2025-02.jsonl.gz?token=YOUR_API_KEY
```

### How do I discover which monthly bulk files are available and when they were last updated?

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.

```bash
https://api.sec-api.io/bulk/audit-fees/index.json?token=YOUR_API_KEY
```

### How do I monitor for newly published audit fee data so I can keep my local copy in sync?

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.

```bash
https://api.sec-api.io/bulk/audit-fees/index.json?token=YOUR_API_KEY
```

### How do I paginate beyond the default page size to collect more than 50 records per query?

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.

```json
{
  "query": "filedAt:[2024-01-01 TO 2024-12-31]",
  "from": 50,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I order results so that the oldest disclosures come first instead of the most recent?

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.

```json
{
  "query": "formType:\"DEF 14A\"",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"asc"}}]
}
```

### How can I track year-over-year changes in audit fees for a single company?

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.

```json
{
  "query": "entities.cik:721994",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"asc"}}]
}
```

### How do I detect when a company switched auditors between two consecutive proxy years?

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`).

```json
{
  "query": "entities.cik:1318605",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I rank the largest U.S. public-company audit engagements by fees paid in a given year?

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`.

```json
{
  "query": "records.year:2023",
  "from": 0,
  "size": 50,
  "sort": [{"records.auditFees":{"order":"desc"}}]
}
```

### How do I compute the average audit fee for companies in a particular industry sector?

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.

```json
{
  "query": "entities.sic:2834* AND records.year:2023",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I combine multiple criteria such as a date window, an industry filter, and a fee threshold into one query?

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`.

```json
{
  "query": "filedAt:[2023-01-01 TO 2023-12-31] AND entities.sic:6022* AND records.auditFees:>500000",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

### How do I identify proxy statements where a company reported fees paid to more than one audit firm in the same fiscal year, indicating a mid-year auditor change?

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.

```json
{
  "query": "filedAt:[2024-01-01 TO 2024-12-31]",
  "from": 0,
  "size": 50,
  "sort": [{"filedAt":{"order":"desc"}}]
}
```

## References

For more information about Form DEF 14A filings and additional resources, visit the following websites:

- [Proxy Rules and Schedules 14A/14C Q&A](https://www.sec.gov/rules-regulations/staff-guidance/compliance-disclosure-interpretations/proxy-rules-schedules-14a14c)
- [Annual Meetings and Proxy Requirements Information](https://www.sec.gov/resources-small-businesses/going-public/annual-meetings-proxy-requirements)