DEV Community: Liam Altie

How I Serve 10,000+ Dynamic Pages for Free with Next.js ISR (and the Mistakes I Made)

Liam Altie — Sat, 14 Mar 2026 06:04:25 +0000

I wanted to build a financial dashboard that covers every public company in the US. That's 10,000+ unique pages — each with charts, tables, and real-time data from the SEC.

The catch? I wanted to host it for free on Vercel's hobby tier.

Here's how I did it, and the bugs that almost killed the project.

The result

secedgardata.com — a free dashboard for 10,000+ public companies.

Search any ticker, see revenue charts, income statements, balance sheets, and SEC filing history. No login, no API key.

The problem: 10,000 pages that can't be static

My backend (FastAPI on a home server) serves financial data for every SEC-registered company. I wanted each company to have its own page: /stock/AAPL, /stock/MSFT, /stock/PLTR, and so on.

The naive approach — generateStaticParams for all tickers — was out:

Build time: 10,000+ API calls at build = minutes of build time
Build server can't reach my backend: Vercel's build servers are in AWS. My backend runs on a mini PC at home behind Tailscale. Connection refused.

That second one burned me. The build looked fine locally, but every deploy on Vercel failed with ECONNRESET.

The fix: On-demand ISR with no static params

// src/app/stock/[ticker]/page.tsx
export const revalidate = 86400; // 24 hours
export const dynamicParams = true;
// No generateStaticParams — all pages are on-demand

That's it. When someone visits /stock/AAPL:

Next.js calls my backend, renders the page
Caches it at the edge for 24 hours
Every subsequent visitor gets the cached version instantly

First visit is ~800ms. After that, it's <50ms from Vercel's CDN.

Mistake #1: Error handling that caches 404s

My API client originally threw errors on network failures:

// ❌ Bad: throws on network errors
const resp = await fetch(url);
if (!resp.ok) throw new Error(`API error: ${resp.status}`);

The problem: if my backend was temporarily down, Next.js would cache the error page as a 404. And that cached 404 would persist for 24 hours.

Amazon's page returned 404 for an entire day because of one transient network blip.

// ✅ Good: return null, let the page show graceful fallback
try {
  const resp = await fetch(url, {
    headers: { "x-dashboard-key": API_KEY },
    next: { revalidate: 86400 },
  });
  if (!resp.ok) return null;
  return resp.json();
} catch {
  return null;
}

Mistake #2: Sentry not working because of Next.js 15

I set up @sentry/nextjs with the standard sentry.client.config.ts. Deployed. Threw test errors. Nothing appeared in Sentry.

Spent an hour checking DSN, environment variables, tunnel routes — everything looked correct. Then I checked the browser console: no Sentry logs at all. The file wasn't even being loaded.

Turns out Next.js 15 with Turbopack ignores sentry.client.config.ts. You need src/instrumentation-client.ts instead:

// src/instrumentation-client.ts
import * as Sentry from "@sentry/nextjs";

Sentry.init({
  dsn: "your-dsn-here",
  tracesSampleRate: 0.1,
});

This is documented in the Sentry SDK source but easy to miss. If you're on Next.js 15 and Sentry events aren't showing up — this is probably why.

The sitemap trick: 10,464 URLs

Google needs to know about all 10,000+ pages. I added a dynamic sitemap:

// src/app/sitemap.ts
export const revalidate = 86400;

export default async function sitemap() {
  const tickers = await getAllTickers(); // ~10,464 tickers

  return tickers.map((t) => ({
    url: `https://secedgardata.com/stock/${t.ticker}`,
    changeFrequency: "weekly",
    priority: 0.8,
  }));
}

Submitted to Google Search Console. Got 10,464 URLs recognized on day one.

One gotcha: make sure the domain in your sitemap matches your Search Console property. I had a stale fallback URL from development and Google rejected all 10,464 URLs as "not permitted." Felt great.

The stack

Layer	Choice	Why
Framework	Next.js 15 (App Router)	ISR, Server Components
Styling	Tailwind + shadcn/ui	Fast to build, dark mode free
Charts	Recharts	Lightweight, React native
Backend	FastAPI (Python)	Already had it for my API
Hosting	Vercel (free tier)	ISR + edge caching
Monitoring	Sentry + Vercel Analytics	Error tracking + PV

Total hosting cost: $0/month (Vercel free tier handles it fine with ISR caching).

For developers: the same data as an API

The backend that powers this dashboard is also available as a REST API:

pip install sec-edgar-sdk

from sec_edgar import SecEdgar
api = SecEdgar("YOUR_RAPIDAPI_KEY")

for year in api.revenue("AAPL", limit=5):
    print(f"FY{year['fiscal_year']}: ${year['value']:,.0f}")

REST API on RapidAPI — Free tier: 100 req/month
Python SDK on PyPI
Source on GitHub

Try it: secedgardata.com

If you hit any bugs or have feature requests, let me know in the comments.

I Published a Python SDK for SEC Financial Data (and It's 6 Methods)

Liam Altie — Sat, 14 Mar 2026 02:39:17 +0000

I recently posted about an API I built for SEC EDGAR data. While writing the example code for that article, I kept looking at all the boilerplate — setting headers, building URLs, parsing responses — and thought, this should just be a pip install.

So I made one.

pip install sec-edgar-sdk

The whole thing is 6 methods

from sec_edgar import SecEdgar

api = SecEdgar("YOUR_RAPIDAPI_KEY")

# Get company info
api.company("AAPL")

# Search companies
api.search("tesla")

# Filing history
api.filings("TSLA", form="10-K", limit=5)

# Financial statements
api.financials("MSFT", statement="income_statement")

# Shortcuts
api.revenue("AAPL", limit=5)
api.net_income("MSFT", limit=3)

That's it. No configuration classes, no builder patterns, no 200-page docs. I wanted something where you read the method name and already know what it does.

What I actually use it for

I've been tracking revenue trends for a handful of companies. Before the SDK, the script looked like this:

import requests

url = "https://sec-edgar-data-api.p.rapidapi.com/v1/financials/AAPL"
headers = {
    "x-rapidapi-key": "YOUR_KEY",
    "x-rapidapi-host": "sec-edgar-data-api.p.rapidapi.com"
}
response = requests.get(url, headers=headers, params={
    "statement": "income_statement", "limit": 5
})
data = response.json()
for item in data["statements"]["income_statement"]:
    if item["concept"] == "revenue":
        for year in item["data"]:
            print(f"FY{year['fiscal_year']}: ${year['value']:,.0f}")

Now:

from sec_edgar import SecEdgar

api = SecEdgar("YOUR_KEY")
for year in api.revenue("AAPL", limit=5):
    print(f"FY{year['fiscal_year']}: ${year['value']:,.0f}")

FY2025: $383,285,000,000
FY2024: $394,328,000,000
FY2023: $365,817,000,000
FY2022: $391,035,000,000
FY2021: $378,323,000,000

3 lines instead of 13. That's the whole point.

Comparing companies side by side

One thing I keep doing — quick earnings comparisons without opening a Bloomberg terminal I don't have:

from sec_edgar import SecEdgar

api = SecEdgar("YOUR_KEY")

for ticker in ["AAPL", "MSFT", "GOOG"]:
    info = api.company(ticker)
    rev = api.revenue(ticker, limit=1)
    latest = rev[0]["value"] if rev else 0
    print(f"{info['name']}: ${latest / 1e9:.1f}B")

Apple Inc.: $383.3B
Microsoft Corporation: $254.2B
Alphabet Inc.: $339.9B

Nothing fancy. Just the kind of thing I used to waste 20 minutes on.

Error handling

The SDK raises SecEdgarError with the status code and detail, so you're not guessing what went wrong:

from sec_edgar.client import SecEdgarError

try:
    api.company("NOTREAL")
except SecEdgarError as e:
    print(e.status_code)  # 404
    print(e.detail)       # "Ticker not found"

The boring details

Wraps the SEC EDGAR Data API on RapidAPI
Free tier: 100 requests/month, no credit card
Uses requests under the hood (the only dependency)
Supports context managers (with SecEdgar(...) as api:)
Python 3.9+
MIT license

Source: github.com/LiamAltie/sec-edgar

If you're working with SEC data and have ideas for what else the SDK should do, I'm all ears. Thinking about adding async support and maybe a CLI, but honestly trying not to over-engineer it.

I Was Tired of Parsing XBRL, So I Built a SEC EDGAR API

Liam Altie — Sat, 14 Mar 2026 01:24:22 +0000

If you've ever tried to pull financial data from the SEC's EDGAR system, you probably know where this is going.

I wanted to build a stock screener. Simple idea — just show me revenue trends for a few companies. Should take an afternoon, right?

Nope. First you need a company's CIK number (Apple is 0000320193 — don't ask me why it's zero-padded to 10 digits). Then you download their XBRL filings, which are nested XML with namespaces like us-gaap:RevenueFromContractWithCustomerExcludingAssessedTax. Then you realize different companies use slightly different tags for the same concept. Then you start questioning your life choices.

I spent way too long on this, so I wrapped the whole thing in a REST API. Pass a ticker, get JSON back. Done.

Show me the data

Company info:

GET /v1/company/AAPL

{
  "cik": "320193",
  "ticker": "AAPL",
  "name": "Apple Inc.",
  "sic": "3571",
  "sic_description": "Electronic Computers",
  "fiscal_year_end": "0926",
  "state": "CA"
}

No CIK lookup. Just the ticker.

Financial statements:

GET /v1/financials/AAPL?statement=income_statement&limit=3

{
  "ticker": "AAPL",
  "name": "Apple Inc.",
  "statements": {
    "income_statement": [
      {
        "concept": "revenue",
        "label": "Revenue from Contract with Customer",
        "unit": "USD",
        "data": [
          {
            "fiscal_year": 2025,
            "fiscal_period": "FY",
            "value": 383285000000.0,
            "filed": "2025-10-31",
            "form": "10-K"
          }
        ]
      }
    ]
  }
}

Revenue, net income, EPS, operating expenses — all the stuff that took me hours to extract from XBRL, now in one call.

Getting Apple's revenue in Python

import requests

url = "https://sec-edgar-data-api.p.rapidapi.com/v1/financials/AAPL"
headers = {
    "x-rapidapi-key": "YOUR_API_KEY",
    "x-rapidapi-host": "sec-edgar-data-api.p.rapidapi.com"
}
params = {"statement": "income_statement", "limit": 5}

response = requests.get(url, headers=headers, params=params)
data = response.json()

for item in data["statements"]["income_statement"]:
    if item["concept"] == "revenue":
        for year in item["data"]:
            print(f"FY{year['fiscal_year']}: ${year['value']:,.0f}")

FY2025: $383,285,000,000
FY2024: $394,328,000,000
FY2023: $365,817,000,000

That stock screener I mentioned? Finally built it.

Other endpoints

Search companies (fuzzy matching, so typos are fine):

GET /v1/company?q=tesla

Filing history — 10-K, 10-Q, 8-K, whatever:

GET /v1/filings/TSLA?form=10-K&limit=5

Balance sheet and cash flow:

GET /v1/financials/MSFT?statement=balance_sheet
GET /v1/financials/MSFT?statement=cash_flow

Covers all 10,000+ SEC-registered public companies. The data comes directly from SEC EDGAR (data.sec.gov), so it updates as companies file.

Why not just use [existing API]?

Fair question. I looked at the alternatives — most are either $50+/month for basic access, or they give you 47 endpoints when you just need 4. I wanted something I could hand to a junior dev and they'd figure it out in 5 minutes. That's basically the design principle: if it needs documentation longer than a README, it's too complicated.

Try it out

Free tier on RapidAPI — 100 requests/month, no credit card:

SEC EDGAR Data API on RapidAPI

I'm also running a bot at @SECEdgarBot that tweets when notable filings drop and flags interesting financial signals. Still early, but it's been fun to build.

All data sourced from SEC EDGAR (data.sec.gov) — publicly available US government data.

Update: I wrapped this API in a Python SDK — pip install sec-edgar-sdk and you're good to go.