v3.2.1

1990 Web Archive Documentation

The most comprehensive API for accessing, searching, and preserving the early web. Archive, retrieve, and render 4.2 million pages from the 1990s with pixel-perfect accuracy.

ℹ️
API v3.2.1 β€” This documentation covers the latest stable release. If you're migrating from v2.x, see our migration guide.

Overview #

1990 Web Archive provides programmatic access to one of the world's largest collections of preserved web content spanning 1990–1999. Our API enables developers to search, retrieve, and render historical web pages exactly as they appeared in their original era.

Whether you're building a digital history platform, conducting academic research, or creating retro-themed applications, our API provides the tools you need with enterprise-grade reliability.

Key Capabilities

  • Search across 4.2M archived pages with era-specific filters
  • Retrieve full HTML, CSS, images, and embedded assets
  • Pixel-perfect rendering in original Netscape/IE environments
  • GeoCities, Angelfire, and personal homepage recovery
  • Cryptographic authentication for legal preservation purposes
  • Real-time webhooks for continuous archive monitoring

Quick Overview #

Here's a taste of what you can do with just a few lines of code:

JavaScript
// Initialize the client
const { ArchiveClient } = require('1990-web-archive');

const archive = new ArchiveClient({
  apiKey: 'your-api-key-here',
  version: 'v3'
});

// Search for pages from the early web
const results = await archive.search({
  query: 'welcome to my homepage',
  yearRange: [1994, 1998],
  siteType: 'personal',
  limit: 10,
  includeAssets: true
});

console.log(`Found ${results.total} pages`);
// β†’ Found 12,847 pages

Supported Web Eras #

Era Years Pages Key Technologies
Pioneer 1990–1993 284K HTTP/0.9, Basic HTML, FTP
Dawn of the Web 1994–1995 892K HTML 2.0, Frames, Images
Golden Age 1996–1997 1.6M HTML 3.2, CSS1, JavaScript
Dot-Com Boom 1998–1999 1.4M HTML 4.01, CSS2, DHTML, Flash

Quick Start Guide

Get up and running with the 1990 Web Archive API in under 5 minutes.

Prerequisites #

  • Node.js 18+ or Python 3.9+
  • A free or paid account at console.1990archive.dev
  • API key (generate in your dashboard)

Step-by-Step #

  1. Install the SDK

    Choose your preferred language and install the official client library.

  2. Configure Your API Key

    Set your API key as an environment variable for secure access.

  3. Perform Your First Search

    Search the archive and retrieve results with a single API call.

  4. Render Archived Content

    Render any archived page in its original era-specific context.

1. Install the SDK

Bash
# Node.js / JavaScript
npm install 1990-web-archive
Bash
# Python
pip install 1990-archive-sdk
Bash
# Go
go get github.com/1990archive/go-sdk
Bash
# Direct API with cURL (no SDK needed)
curl -X GET \
  https://api.1990archive.dev/v3/search \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -d '{"query": "welcome", "yearRange": [1994, 1996]}'

2. Configure Your API Key

Bash
# Set your API key in your environment
export ARCHIVE_API_KEY="sk-1990-a1b2c3d4e5f6..."
JavaScript
const { ArchiveClient } = require('1990-web-archive');

const client = new ArchiveClient({
  apiKey: process.env.ARCHIVE_API_KEY
});

// Search for classic personal homepages
const pages = await client.pages.search({
  query: "under construction",
  year: 1996,
  limit: 5
});

pages.forEach(page => {
  console.log(-`${page.title} (${page.url})`);
});

4. Render Archived Content

JavaScript
// Render a page in its original browser context
const rendered = await client.render.render(page.id, {
  browser: "netscape4",       // or "ie5", "opera5", "mozilla1"
  resolution: "800x600",     // standard for the era
  viewportWidth: 800,
  includeFlash: true,         // includes archived .swf files
  includeFrames: true         // includes frame structures
});

// Get the rendered HTML with all assets
console.log(rendered.html);          // full HTML document
console.log(rendered.assets);       // { css: [], images: [], scripts: [] }
console.log(rendered.screenshot);   // base64 PNG screenshot
πŸ’‘
Pro Tip: Use the --render flag with the render method to get a real-time preview URL instead of raw HTML. Perfect for debugging and integration testing.

Installation #

Install the 1990 Web Archive SDK for your development environment.

SDK Requirements #

Requirement Minimum Version Recommended
Node.js18.020.x LTS
Python3.93.12+
Go1.211.22+
Ruby3.03.3+
PHP8.18.3+
.NET8.09.0

Node.js / JavaScript #

Bash
# Using npm
npm install 1990-web-archive

Python #

Bash
# Using pip
pip install 1990-archive-sdk

Go #

Bash
# Using Go modules
go get github.com/1990archive/go-sdk/v3

Direct REST API (No SDK) #

If you prefer to interact with the API directly via HTTP, all endpoints are available at:

URL
https://api.1990archive.dev/v3/
ℹ️
Base URL: All API requests should be made to https://api.1990archive.dev/v3/. The v3 prefix ensures API version compatibility.

Authentication #

Manage your API keys and configure secure access to the archive.

API Keys #

All API requests require authentication via an API key. You can generate and manage your keys from the Developer Console.

Key Types

Type Prefix Purpose Rate Limit
Production sk-1990- Live applications 1,000 req/min
Development dk-1990- Testing & development 100 req/min
Read-Only rk-1990- Read-only access 500 req/min

Authentication Methods #

Method 1: Authorization Header

HTTP
GET /v3/search HTTP/1.1
Host: api.1990archive.dev
Authorization: Bearer sk-1990-a1b2c3d4e5f6...
Content-Type: application/json

Method 2: Environment Variable

Bash
# Recommended for server-side applications
export ARCHIVE_API_KEY="sk-1990-a1b2c3d4e5f6..."
🚨
Security Warning: Never expose your API key in client-side code, public repositories, or browser-accessible paths. Use environment variables or a secrets manager for production deployments.

JWT Tokens #

For server-to-server communication, you can use JWT tokens instead of API keys. JWT tokens provide short-lived access and are ideal for microservice architectures.

JavaScript
const { AuthService } = require('1990-web-archive');

// Generate a JWT token (valid for 1 hour)
const token = await AuthService.generateJWT({
  apiKey: process.env.ARCHIVE_API_KEY,
  ttl: 3600,  // seconds
  scopes: ["search:read", "pages:read"]
});

// Use the token in subsequent requests
const client = new ArchiveClient({
  authToken: token
});

Rate Limits #

Plan Requests/min Requests/day Concurrent Jobs
Free301,0001
Developer10010,0003
Professional500100,00010
Enterprise1,000Unlimited50

API Reference

Complete reference for all 1990 Web Archive API endpoints, parameters, and response formats.

ℹ️
Base URL: https://api.1990archive.dev/v3/ β€” All endpoints are prefixed with this base URL.

Search Archive #

GET /search

Search across the entire archive using keywords, date ranges, and content filters.

Query Parameters

Parameter Type Required Description
query string Yes Search query text. Supports full-text search across page content, titles, and URLs.
yearRange array No Filter by year range. Format: [start_year, end_year]
siteType string No Filter by site type: personal, business, government, edu, nonprofit
language string No ISO 639-1 language code. Default: en
technology string No Filter by detected technology: netscape, ie, frameset, javascript, flash
limit integer No Number of results per page (1–100). Default: 20
offset integer No Pagination offset. Default: 0
includeAssets boolean No Include associated assets (images, CSS, JS) in response. Default: false
sort string No Sort order: relevance (default), date_asc, date_desc, title

Example Request

cURL
curl -X GET \
  https://api.1990archive.dev/v3/search \
  -H 'Authorization: Bearer sk-1990-a1b2c3d4e5f6' \
  -G \
  -d 'query=welcome to my homepage' \
  -d 'yearRange=1994,1998' \
  -d 'siteType=personal' \
  -d 'technology=frameset' \
  -d 'limit=10' \
  -d 'includeAssets=true'

Response

JSON
{