Datamule SEC Filings Metadata

• Requires a Metadata subscription.
• Filing headers, associated entities, former company names, fund series and classes, filer profiles and name history, document metadata, accession-to-CIK mappings, monitor dumps, and realtime filing detections.
• The five filing metadata tables include newly processed filings in SQL queries by default; use from_storage="daily" for cheaper daily-only queries. Other historical datasets update daily. Fastest SEC Filings Metadata is updated in realtime.

Usage

See the dataset documentation for download and query options, and products for pricing.

The Metadata subscription includes twelve queryable tables:

• submissions_metadata
• filer_metadata
• filer_names
• sec_submission_details_table
• sec_accession_cik_table
• sec_documents_table
• monitor_dumps
• filing_metadata_filings
• filing_metadata_entities
• filing_metadata_former_companies
• filing_metadata_series
• filing_metadata_classes

It also includes the fastest_sec_filings_metadata API for querying realtime filing detections.

Query Database

Use datamulehub.databases.query when you want Athena to run SQL and write the result as Parquet files.

from datamulehub import databases

databases.query(
    """
    SELECT
        accessionnumber,
        cik,
        "form",
        filingdate,
        reportdate,
        primarydocument
    FROM submissions_metadata
    WHERE filingdate >= '2024-01-01'
      AND "form" IN ('10-K', '10-Q')
    LIMIT 1000
    """,
    output_dir="metadata_sample",
)

This writes one or more Parquet files to metadata_sample.

You can also join metadata tables. For example, this joins submission details, accession-to-CIK mappings, and document rows:

from datamulehub import databases

databases.query(
    """
    SELECT
        d.accessionnumber,
        c.cik,
        d.submissiontype,
        d.filingdate,
        doc.sequence,
        doc.documenttype,
        doc.filename,
        doc.description
    FROM sec_submission_details_table d
    JOIN sec_accession_cik_table c
      ON d.accessionnumber = c.accessionnumber
    JOIN sec_documents_table doc
      ON d.accessionnumber = doc.accessionnumber
    WHERE d.submissiontype = '10-K'
      AND d.filingdate >= '2024-01-01'
      AND doc.documenttype = '10-K'
    LIMIT 1000
    """,
    output_dir="ten_k_documents",
)

The filing metadata tables contain the header fields recorded in each filing. For example, this joins filing headers and entities with the submission details lookup:

from datamulehub import databases

databases.query(
    """
    SELECT
        f.accessionnumber,
        f.filingdate,
        d.submissiontype,
        e.entity_cik,
        e.entity_role,
        e.company_data__conformed_name,
        e.company_data__assigned_sic
    FROM filing_metadata_filings f
    JOIN sec_submission_details_table d
      ON f.accessionnumber = d.accessionnumber
    JOIN filing_metadata_entities e
      ON f.accessionnumber = e.accessionnumber
    WHERE d.submissiontype = '10-K'
      AND f.filingdate >= '2024-01-01'
      AND e.entity_role = 'filer'
    LIMIT 1000
    """,
    output_dir="ten_k_filing_entities",
)

Filer profiles and name history can also be joined by CIK:

from datamulehub import databases

databases.query(
    """
    SELECT
        f.cik,
        f.name AS current_name,
        f.tickers,
        n.name,
        n.start_date,
        n.end_date
    FROM filer_metadata f
    JOIN filer_names n ON f.cik = n.cik
    WHERE f.cik = 789019
    """,
    output_dir="filer_name_history",
)

Read Query

Use datamulehub.databases.read_query when you want a small query result back in Python instead of keeping the Parquet files.

from datamulehub import databases

rows = databases.read_query(
    """
    SELECT
        accession,
        source,
        detected_time
    FROM monitor_dumps
    WHERE source = 'anticipate'
    LIMIT 10
    """
)

print(rows)

read_query downloads the Parquet result files to a temporary directory, reads them, and returns the rows.

Download Dataset

Use datamulehub.datasets.download when you want a full metadata dataset.

from datamulehub import datasets

datasets.download(
    "submissions_metadata",
    filename="submissions_metadata.parquet",
)

datasets.download(
    "sec_submission_details_table",
    filename="sec_submission_details_table.parquet",
)

datasets.download(
    "sec_accession_cik_table",
    filename="sec_accession_cik_table.parquet",
)

datasets.download(
    "sec_documents_table",
    filename="sec_documents_table.parquet",
)

datasets.download(
    "filer_metadata",
    filename="filer_metadata.parquet",
)

datasets.download(
    "filer_names",
    filename="filer_names.parquet",
)

The five filing metadata tables also support from_storage. Use daily for the full daily dataset, delta for recent per-filing data, or both to add recent filings not yet in the daily dataset. The default is both.

from datamulehub import datasets

# Full daily dataset.
datasets.download(
    "filing_metadata_filings",
    filename="filing_metadata_filings.parquet",
    from_storage="daily",
)

# Full dataset plus recent filings. Deduplicated.
datasets.download(
    "filing_metadata_entities",
    filename="filing_metadata_entities.parquet",
)

datasets.download(
    "filing_metadata_former_companies",
    filename="filing_metadata_former_companies.parquet",
)

datasets.download(
    "filing_metadata_series",
    filename="filing_metadata_series.parquet",
)

datasets.download(
    "filing_metadata_classes",
    filename="filing_metadata_classes.parquet",
)

monitor_dumps is organized by date in S3, so the easiest way to work with it is usually through databases.query or databases.read_query.

fastest_sec_filings_metadata

Query detections from the Fastest SEC Filings service through datamulehub.databases. Usage costs $10 per million records returned, with a minimum charge of $0.001 per query.

Use read_query to return the records in Python:

from datamulehub import databases

rows = databases.read_query(
    """
    SELECT *
    FROM fastest_sec_filings_metadata
    ORDER BY detected_time DESC
    LIMIT 100
    """
)

print(rows)

Use query to write the result as a Parquet file:

from datamulehub import databases

databases.query(
    """
    SELECT accession, ciks, submission_type, detected_time, detection_method
    FROM fastest_sec_filings_metadata
    WHERE detection_method = 'index_url'
    LIMIT 100
    """,
    output_dir="fastest_filings_metadata",
)

Supported query shapes are:

• Look up one exact accession.
• Return the latest filings overall with ORDER BY detected_time DESC.
• Filter or order by a detected_time range. Detection times are Unix timestamps in milliseconds.
• Filter by one of cik, submission_type, or detection_method.

A cik, submission_type, or detection_method filter cannot be combined with a detected_time filter or ORDER BY. For example, filtering by detection_method = 'index_url' returns matching records, but does not mean the latest matching records.

Exact accession lookup:

SELECT *
FROM fastest_sec_filings_metadata
WHERE accession = '0001104659-23-015159'

Detected-time range:

SELECT *
FROM fastest_sec_filings_metadata
WHERE detected_time >= 1756684800000
  AND detected_time < 1756771200000
ORDER BY detected_time ASC
LIMIT 1000

Each result contains:

Tables

Schemas below use the Athena table and column names from athena_tables.json.

filer_metadata

SEC filer profiles with current names, tickers, exchanges, industry codes, and addresses. Includes individuals and companies with or without tickers. Extracted from the SEC bulk submissions data.

Athena table and dataset name: filer_metadata

cik is an integer. tickers and exchanges are arrays of strings. Missing values are null.

filer_names

Current and former SEC filer names. One filer can have several name records. Extracted from the SEC bulk submissions data.

Athena table and dataset name: filer_names

Dates use YYYY-MM-DD strings. end_date is null for the current name. Name dates come from SEC name history, falling back to filing history when needed; they are not incorporation dates.

submissions_metadata

Comprehensive filing metadata extracted from the SEC bulk submissions data.

Athena table and dataset name: submissions_metadata

Note: 'accessionnumber' here is e.g. '0001157523-05-000798'. whereas everywhere else it is 115752305000798. This will be fixed.

sec_submission_details_table

Small filing-level lookup table used by the SEC filings archive.

Athena table and dataset name: sec_submission_details_table

sec_accession_cik_table

Maps each accession number to one or more CIKs.

Athena table and dataset name: sec_accession_cik_table

sec_documents_table

Document-level metadata for files inside SEC submissions.

Athena table and dataset name: sec_documents_table

Filing Metadata Tables

Metadata extracted from SEC filing headers and flattened into five tables. Document rows are available through sec_documents_table.

filing_metadata_filings

Filing-level fields from the SEC submission header, including submission type, acceptance time, reporting period, and filing values. Fields vary by submission type and header format.

Athena table and dataset name: filing_metadata_filings

filing_metadata_entities

Athena table and dataset name: filing_metadata_entities

filing_metadata_former_companies

Former company names and name-change dates recorded in filing headers. Join to filing_metadata_entities on accessionnumber, entity_cik, and entity_role.

Athena table and dataset name: filing_metadata_former_companies

filing_metadata_series

Fund series recorded in filing headers. owner_cik identifies the owner of the series.

Athena table and dataset name: filing_metadata_series

filing_metadata_classes

Fund classes and contracts recorded in filing headers, including names and ticker symbols. Join to filing_metadata_series on accessionnumber, owner_cik, and series_id.

Athena table and dataset name: filing_metadata_classes

monitor_dumps

Detection-time records for Datamule filing monitors. The source field includes sources such as Efts, Rss, and anticipate.

Athena table name: monitor_dumps