EdgarKit API

A clean, real-time JSON API for SEC EDGAR Form 3, 4, and 5 insider trading filings. Stop scraping SEC's HTML. Stop parsing XML. Start building.

What's in the data

• Form 3 — initial statement of beneficial ownership (when an insider relationship begins)
• Form 4 — changes in ownership (the main one — buys, sells, grants, options exercises)
• Form 4/A — amendments to a previously filed Form 4
• Form 5 — annual statement of changes (catches anything missed during the year)

How fresh is it

EdgarKit polls SEC EDGAR every 30 seconds. End-to-end latency from SEC publishing a filing to it being queryable through our API is 30 to 60 seconds. Webhooks fire within that same window.

How far back

The API contains historical filings going back approximately 2 years from the date you read this. Older history can be added on request — reach out.

Quickstart

1. Get an API key — Sign up at edgarkit.com. Instant. No credit card needed.
2. Make your first request

   curl "https://api.edgarkit.com/v1/companies/NVDA/filings?limit=5" \
     -H "Authorization: Bearer $EDGARKIT_KEY"

3. Optionally register a webhook — Get pinged the moment a filing matches your filters. See Webhook setup.

Try it now

No API key needed. Enter a ticker symbol below and run a live query against the EdgarKit API.

curl "https://api.edgarkit.com/v1/public/feed?ticker=NVDA"

Click "Run query" to fetch live data.

Authentication

All API requests require a bearer token in the Authorization header.

Authorization: Bearer ek_live_xxxxxxxxxxxxxxxxxxxxxxxx

Key safety

• Treat your key like a password. Never commit it to source control.
• Use environment variables: process.env.EDGARKIT_KEY in Node, os.getenv('EDGARKIT_KEY') in Python.
• If your key leaks, rotate it from the dashboard. Old keys are immediately invalidated.

Key prefixes

• ek_live_ — production traffic
• ek_test_ — sandbox (coming soon)

Rate limits

Rate limits are enforced per API key. Limits depend on your plan.

Response headers

Every response includes:

• X-RateLimit-Limit — your plan's per-minute limit
• X-RateLimit-Remaining — calls left in the current minute
• X-RateLimit-Reset — Unix timestamp when the window resets

When you hit the limit

You'll get a 429 Too Many Requests with a Retry-After header (in seconds). Back off and retry.

Errors

EdgarKit returns standard HTTP status codes plus a JSON body with an error code and message.

{
  "error": {
    "code": "not_found",
    "message": "No filing with accession 0001234567-26-000001"
  }
}

Webhook setup

Webhooks are how you get pushed notifications when filings match your criteria. Available on Basic and Pro plans.

Register a webhook

curl "https://api.edgarkit.com/v1/webhooks" -X POST \
  -H "Authorization: Bearer $EDGARKIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://yourapp.com/edgarkit-webhook",
    "filter": {
      "tickers": ["AAPL"],
      "transaction_codes": ["S"],
      "min_value": 1000000
    }
  }'

What you receive

When a filing matches, we POST the full filing object plus a signature header. Your endpoint should respond with a 2xx within 10 seconds.

Retry behavior

If your endpoint returns non-2xx or times out, we retry with exponential backoff: 30s, 2m, 10m, 1h, 6h. After 5 failures we mark the delivery as failed and surface it in your dashboard.

Filter fields

• tickers — array of ticker symbols
• ciks — array of CIKs (issuer or reporter)
• form_types — array, e.g. ["4", "4/A"]
• transaction_codes — array, e.g. ["S", "P"]
• min_value — minimum total transaction value in dollars

Verifying HMAC signatures

Every webhook POST includes X-EdgarKit-Signature and X-EdgarKit-Timestamp headers. Always verify these before trusting the payload.

Node.js

// Express middleware
const crypto = require('crypto');

function verify(req) {
  const sig = req.headers['x-edgarkit-signature'];
  const ts  = req.headers['x-edgarkit-timestamp'];
  const body = JSON.stringify(req.body);
  const expected = crypto
    .createHmac('sha256', process.env.WEBHOOK_SECRET)
    .update(ts + '.' + body)
    .digest('hex');
  return crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(expected));
}

Python

import hmac, hashlib, os

def verify(request):
    sig = request.headers['X-EdgarKit-Signature']
    ts  = request.headers['X-EdgarKit-Timestamp']
    body = request.body.decode()
    expected = hmac.new(
        os.environ['WEBHOOK_SECRET'].encode(),
        (ts + '.' + body).encode(),
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(sig, expected)

Pagination

All list endpoints use limit/offset pagination.

# Page 1: first 100 results
curl "https://api.edgarkit.com/v1/filings?limit=100&offset=0" -H ...

# Page 2: next 100
curl "https://api.edgarkit.com/v1/filings?limit=100&offset=100" -H ...

Responses include a pagination object with limit, offset, and count (rows returned in this page).

Form types explained

Transaction codes

The transaction_code field on each transaction tells you what happened. Most common:

P (purchase) and S (sale) are usually what people care about. A is mostly noise from RSU vesting.

Node.js example

// npm install undici
import { fetch } from 'undici';

const KEY = process.env.EDGARKIT_KEY;

async function getRecentSales(ticker) {
  const res = await fetch(
    `https://api.edgarkit.com/v1/companies/${ticker}/filings?limit=10`,
    { headers: { Authorization: `Bearer ${KEY}` } }
  );
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json();
}

getRecentSales('NVDA').then(({ data }) => {
  data.forEach(f => console.log(f.filed_at, f.reporter.name, f.issuer.ticker));
});

Python example

# pip install requests
import os, requests

KEY = os.environ['EDGARKIT_KEY']

def get_recent_sales(ticker):
    r = requests.get(
        f'https://api.edgarkit.com/v1/companies/{ticker}/filings',
        headers={'Authorization': f'Bearer {KEY}'},
        params={'limit': 10},
    )
    r.raise_for_status()
    return r.json()

for f in get_recent_sales('NVDA')['data']:
    print(f['filed_at'], f['reporter']['name'], f['issuer']['ticker'])

curl example

export EDGARKIT_KEY=ek_live_xxxxx

# Recent NVDA insider activity
curl "https://api.edgarkit.com/v1/companies/NVDA/filings?limit=10" \
  -H "Authorization: Bearer $EDGARKIT_KEY" | jq

# Filing detail
curl "https://api.edgarkit.com/v1/filings/0001768670-26-000002" \
  -H "Authorization: Bearer $EDGARKIT_KEY" | jq

Changelog

• 2026-06-11 — Added /v1/public/feed (no-auth latest filings, IP rate-limited), /v1/health (status + freshness), and /v1/openapi.json (OpenAPI 3.0 spec).
• 2026-06-11 — Ingestion poll interval reduced from 5 min to 30 sec. End-to-end webhook latency now ~30-60 sec.
• 2026-06-10 — Added 2 years of historical Form 3/4/5 data via backfill.
• 2026-06-10 — Fixed filed_before date filter to include the full requested day.
• 2026-06-09 — Initial release. Form 3/4/5 ingestion, REST API, webhooks with filters, HMAC signing.

Support

Found a bug? Have a feature request? Email support@edgarkit.com.

I read every email and reply personally.