API Reference v1

Build with adoption intelligence

The architectures.app API gives you real-time package adoption data from 127K+ GitHub repositories. Ground your AI coding assistants in real data, track competitive adoption, and make data-backed architectural decisions.

127K+ Repositories analyzed
9 API endpoints
5 MCP tools
Quick start
# Get trending migrations right now
curl "https://architectures-worker.vguruprasad91.workers.dev/api/trending" \
  -H "Authorization: Bearer arch_xxx"

# Response
{
  "trending": [{
    "from_name": "Prisma",
    "to_name": "Drizzle ORM",
    "velocity": 67,
    "direction": "accelerating"
  }]
}

Authentication

The API supports two authentication methods. For programmatic access, use API keys. Session cookies are used only by the web dashboard.

Recommended

API Keys

Pass your API key in the Authorization header as a Bearer token. Keys are prefixed with arch_ for easy identification.

2
Upgrade to Pro ($29/mo) for programmatic API access
3
Generate a key in Account → API Keys
Web only

Session Cookies

The web dashboard uses HTTP-only session cookies for authentication. These are set automatically on login and are not suitable for API integration. Use API keys instead.

Authentication flow

Request
API key?
Yes
Validate key
Check tier
Allow
No
Session cookie?
Yes
Allow
No
401
curl "https://architectures-worker.vguruprasad91.workers.dev/api/trending" \
  -H "Authorization: Bearer arch_xxxxxxxxxxxx"
const response = await fetch(
  'https://architectures-worker.vguruprasad91.workers.dev/api/trending',
  {
    headers: {
      Authorization: 'Bearer arch_xxxxxxxxxxxx'
    }
  }
);

const data = await response.json();
import requests

response = requests.get(
    "https://architectures-worker.vguruprasad91.workers.dev/api/trending",
    headers={"Authorization": "Bearer arch_xxxxxxxxxxxx"}
)

data = response.json()
Replace arch_xxxxxxxxxxxx with your actual API key

Rate Limits

Rate limits are applied per API key (or per IP for unauthenticated requests). All responses include rate limit headers so you can track your usage.

Tier Requests/hr Burst Historical Co-occurrence Comparisons
Free 60 10/min 30 days Top 20 pairs Top 10
Pro $29/mo 1,000 100/min 12 months Unlimited All
Enterprise $299/mo Unlimited Unlimited Full history Unlimited + Custom All + Private

Rate limit headers

Every API response includes these headers:

X-RateLimit-Limit Maximum requests allowed in the current window
X-RateLimit-Remaining Requests remaining in the current window
X-RateLimit-Reset Unix timestamp (seconds) when the window resets
Retry-After Seconds to wait before retrying (only present on 429 responses)
Response headers
HTTP/1.1 200 OK
X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 994
X-RateLimit-Reset: 1711929600
Content-Type: application/json
429 Too Many Requests
HTTP/1.1 429 Too Many Requests
Retry-After: 47
X-RateLimit-Limit: 60
X-RateLimit-Remaining: 0

{
  "error": "Rate limit exceeded",
  "message": "You've exceeded 60 requests/hour on the free tier",
  "code": "RATE_LIMIT_EXCEEDED",
  "upgrade_url": "https://architectures-app.pages.dev/register?plan=pro"
}

API Endpoints

All endpoints are served from https://architectures-worker.vguruprasad91.workers.dev

Base URL: https://architectures-worker.vguruprasad91.workers.dev

GET /api/packages

List Packages

Returns all tracked packages with adoption metrics, growth rates, and monthly trend data. Use this to build dashboards, leaderboards, or feed data into your analytics pipeline.

Query Parameters

category
string Default: all
Filter by category: Frameworks, ORMs, Bundlers, Testing, CSS, State Management, etc.
sort
string Default: downloads
Sort field: downloads, repos, stars, growth
limit
number Default: 50
Maximum number of results to return
offset
number Default: 0
Offset for pagination
ecosystem
string Default: npm
Package ecosystem: npm, pypi, cargo, go

Response Fields

packages[].name
string
Package identifier (npm name)
packages[].displayName
string
Human-readable display name
packages[].category
string
Category classification
packages[].weeklyDownloads
number
Weekly download count from npm
packages[].repos
number
Number of tracked repositories using this package
packages[].stars
number
GitHub star count
packages[].growthRate
number
Growth percentage over the trailing period
packages[].monthlyData
number[]
Array of 12 monthly repo count data points
total
number
Total matching packages (for pagination)
curl -H "Authorization: Bearer arch_xxx" \
  "https://architectures-worker.vguruprasad91.workers.dev/api/packages?category=ORMs&sort=growth&limit=10"
const response = await fetch(
  'https://architectures-worker.vguruprasad91.workers.dev/api/packages?category=ORMs&sort=growth',
  { headers: { Authorization: 'Bearer arch_xxx' } }
);
const { packages, total } = await response.json();

// Display the fastest-growing packages
packages.forEach(pkg => {
  console.log(`${pkg.displayName}: ${pkg.growthRate}% growth, ${pkg.repos} repos`);
});
import requests

response = requests.get(
    "https://architectures-worker.vguruprasad91.workers.dev/api/packages",
    headers={"Authorization": "Bearer arch_xxx"},
    params={"category": "ORMs", "sort": "growth"}
)
data = response.json()

for pkg in data["packages"]:
    print(f"{pkg['displayName']}: {pkg['growthRate']}% growth")
Sample response
{
  "packages": [
    {
      "name": "drizzle-orm",
      "displayName": "Drizzle ORM",
      "category": "ORMs",
      "weeklyDownloads": 620000,
      "repos": 8900,
      "stars": 24000,
      "growthRate": 67.3,
      "trend": "up",
      "monthlyData": [3200, 3800, 4500, 5100, 5800, 6400, 7100, 7600, 8000, 8400, 8700, 8900]
    }
  ],
  "total": 42,
  "page": 1
}
GET /api/packages/:name

Package Detail

Returns detailed adoption data for a single package including full historical trends, co-occurrence data, and migration relationships.

Path Parameters

:name
string Required
Package name (e.g., drizzle-orm, react, hono)

Response Fields

name
string
Package identifier
displayName
string
Human-readable display name
category
string
Category classification
weeklyDownloads
number
Current weekly download count
repos
number
Number of tracked repositories
stars
number
GitHub star count
growthRate
number
Growth percentage over trailing period
monthlyData
number[]
12 months of repo adoption data points
cooccurrence
string[]
Top packages that frequently appear alongside this one
migratingFrom
string[]
Packages that repos are migrating FROM to adopt this one
migratingTo
string[]
Packages that repos are migrating TO from this one
curl -H "Authorization: Bearer arch_xxx" \
  "https://architectures-worker.vguruprasad91.workers.dev/api/packages/drizzle-orm"
const response = await fetch(
  'https://architectures-worker.vguruprasad91.workers.dev/api/packages/drizzle-orm',
  { headers: { Authorization: 'Bearer arch_xxx' } }
);
const pkg = await response.json();

console.log(`Growth: ${pkg.growthRate}%`);
console.log(`Ships with: ${pkg.cooccurrence.join(', ')}`);
console.log(`Replacing: ${pkg.migratingFrom.join(', ')}`);
import requests

response = requests.get(
    "https://architectures-worker.vguruprasad91.workers.dev/api/packages/drizzle-orm",
    headers={"Authorization": "Bearer arch_xxx"}
)
pkg = response.json()

print(f"Growth: {pkg['growthRate']}%")
print(f"Co-occurs with: {', '.join(pkg['cooccurrence'])}")
Sample response
{
  "name": "drizzle-orm",
  "displayName": "Drizzle ORM",
  "category": "ORMs",
  "weeklyDownloads": 620000,
  "repos": 8900,
  "stars": 24000,
  "growthRate": 67.3,
  "trend": "up",
  "monthlyData": [3200, 3800, 4500, 5100, 5800, 6400, 7100, 7600, 8000, 8400, 8700, 8900],
  "cooccurrence": ["typescript", "postgres", "next", "zod", "tailwindcss"],
  "migratingFrom": ["prisma", "typeorm", "sequelize"],
  "migratingTo": []
}
GET /api/compare/:a/:b

Compare Two Packages

Head-to-head comparison of two packages with adoption data, migration counts, and co-occurrence analysis. Returns a structured verdict with data-backed reasoning.

Path Parameters

:a
string Required
First package name (e.g., prisma)
:b
string Required
Second package name (e.g., drizzle-orm)

Response Fields

statsA / statsB
object
Full package stats for each side (downloads, repos, stars, growth)
adoptionCurves
object
Monthly adoption data for both packages, aligned for comparison
migrationCounts
object
Number of repos migrating A-to-B and B-to-A
cooccurrenceA / cooccurrenceB
string[]
Top co-occurring packages for each side
verdict
object
Data-backed comparison summary with winner by category
Use case: Power a "vs" comparison widget in your developer tool's documentation to show real adoption data.
curl -H "Authorization: Bearer arch_xxx" \
  "https://architectures-worker.vguruprasad91.workers.dev/api/compare/prisma/drizzle-orm"
const response = await fetch(
  'https://architectures-worker.vguruprasad91.workers.dev/api/compare/prisma/drizzle-orm',
  { headers: { Authorization: 'Bearer arch_xxx' } }
);
const comparison = await response.json();

console.log(`Verdict: ${comparison.verdict.summary}`);
console.log(`Migrations A->B: ${comparison.migrationCounts.aToB}`);
console.log(`Migrations B->A: ${comparison.migrationCounts.bToA}`);
import requests

response = requests.get(
    "https://architectures-worker.vguruprasad91.workers.dev/api/compare/prisma/drizzle-orm",
    headers={"Authorization": "Bearer arch_xxx"}
)
comp = response.json()

print(f"Verdict: {comp['verdict']['summary']}")
Sample response
{
  "statsA": {
    "name": "prisma",
    "repos": 18200,
    "weeklyDownloads": 1840000,
    "growthRate": 12.1
  },
  "statsB": {
    "name": "drizzle-orm",
    "repos": 8900,
    "weeklyDownloads": 620000,
    "growthRate": 67.3
  },
  "migrationCounts": {
    "aToB": 234,
    "bToA": 12
  },
  "verdict": {
    "summary": "Drizzle is growing 5.6x faster. 234 repos migrated Prisma->Drizzle vs 12 the other way.",
    "momentum": "drizzle-orm",
    "marketShare": "prisma"
  }
}
GET /api/cooccurrence/:name

Co-occurrence Graph

Returns packages that frequently appear alongside the specified package across repositories. Strength is measured using the Jaccard similarity coefficient: the intersection of repos using both packages divided by the union of repos using either.

Path Parameters

:name
string Required
Package name to find co-occurrences for

Response Fields

package
string
The queried package name
connections[].target
string
Name of the co-occurring package
connections[].strength
number
Jaccard similarity coefficient (0-1). Higher values indicate stronger co-occurrence.
connections[].sharedRepos
number
Absolute count of repos using both packages
Use case: Suggest complementary packages when a developer adds a dependency to their project.
curl -H "Authorization: Bearer arch_xxx" \
  "https://architectures-worker.vguruprasad91.workers.dev/api/cooccurrence/hono"
const response = await fetch(
  'https://architectures-worker.vguruprasad91.workers.dev/api/cooccurrence/hono',
  { headers: { Authorization: 'Bearer arch_xxx' } }
);
const { connections } = await response.json();

// Find the strongest pairing
const best = connections[0];
console.log(`Hono pairs best with ${best.target} (strength: ${best.strength})`);
import requests

response = requests.get(
    "https://architectures-worker.vguruprasad91.workers.dev/api/cooccurrence/hono",
    headers={"Authorization": "Bearer arch_xxx"}
)
data = response.json()

for conn in data["connections"][:5]:
    print(f"{conn['target']}: strength {conn['strength']:.2f}")
Sample response
{
  "package": "hono",
  "connections": [
    { "target": "typescript", "strength": 0.82, "sharedRepos": 2840 },
    { "target": "drizzle-orm", "strength": 0.68, "sharedRepos": 1920 },
    { "target": "zod", "strength": 0.61, "sharedRepos": 1640 },
    { "target": "vitest", "strength": 0.54, "sharedRepos": 1380 },
    { "target": "wrangler", "strength": 0.48, "sharedRepos": 1120 }
  ]
}
GET /api/migrations

Migration Feed

Returns a feed of all detected migration patterns between packages. Filter by source, destination, or category to find specific migration trends.

Query Parameters

from
string Optional
Filter by source package (e.g., express)
to
string Optional
Filter by destination package (e.g., hono)
category
string Default: all
Filter by category
limit
number Default: 20
Maximum results to return
sort
string Default: velocity
Sort by: velocity, repos, recent

Response Fields

migrations[].from
string
Source package name
migrations[].to
string
Destination package name
migrations[].velocity
number
Migration velocity (repos/month)
migrations[].totalRepos
number
Total repos that have completed this migration
migrations[].category
string
Package category
# All migrations away from Express
curl -H "Authorization: Bearer arch_xxx" \
  "https://architectures-worker.vguruprasad91.workers.dev/api/migrations?from=express&sort=velocity"
const response = await fetch(
  'https://architectures-worker.vguruprasad91.workers.dev/api/migrations?from=express',
  { headers: { Authorization: 'Bearer arch_xxx' } }
);
const { migrations } = await response.json();

// Where are Express users going?
migrations.forEach(m => {
  console.log(`Express -> ${m.to}: ${m.velocity} repos/month`);
});
import requests

response = requests.get(
    "https://architectures-worker.vguruprasad91.workers.dev/api/migrations",
    headers={"Authorization": "Bearer arch_xxx"},
    params={"from": "express", "sort": "velocity"}
)
migrations = response.json()["migrations"]

for m in migrations:
    print(f"Express -> {m['to']}: {m['velocity']} repos/month")
Sample response
{
  "migrations": [
    {
      "from": "express",
      "to": "hono",
      "velocity": 43,
      "totalRepos": 891,
      "category": "framework"
    },
    {
      "from": "express",
      "to": "fastify",
      "velocity": 28,
      "totalRepos": 562,
      "category": "framework"
    }
  ]
}
GET /api/ecosystem

Ecosystem Overview

Returns a high-level view of an entire package ecosystem organized by categories, with leaders identified for each category.

Query Parameters

system
string Default: npm
Package ecosystem: npm, pypi, cargo, go, maven, nuget

Response Fields

ecosystem
string
The ecosystem name
categories[].name
string
Category name (e.g., "Frameworks", "ORMs")
categories[].leader
object
The current category leader with stats
categories[].challenger
object
The fastest-growing challenger
categories[].totalPackages
number
Total tracked packages in this category
Request
curl -H "Authorization: Bearer arch_xxx" \
  "https://architectures-worker.vguruprasad91.workers.dev/api/ecosystem?system=npm"
Sample response
{
  "ecosystem": "npm",
  "categories": [
    {
      "name": "Frameworks",
      "leader": {
        "name": "next",
        "repos": 42000
      },
      "challenger": {
        "name": "hono",
        "growthRate": 42.1
      },
      "totalPackages": 12
    },
    {
      "name": "ORMs",
      "leader": {
        "name": "prisma",
        "repos": 18200
      },
      "challenger": {
        "name": "drizzle-orm",
        "growthRate": 67.3
      },
      "totalPackages": 8
    }
  ]
}
GET /api/stats

Platform Statistics

Returns platform-wide statistics including total repositories analyzed, packages tracked, migrations detected, and data freshness.

Query Parameters

No parameters required.

Response Fields

totalRepos
number
Total GitHub repositories analyzed
totalPackages
number
Total packages tracked across ecosystems
totalMigrations
number
Total migration patterns detected
lastUpdated
string
ISO 8601 timestamp of last data pipeline run
ecosystems
string[]
Supported ecosystems
Request
curl -H "Authorization: Bearer arch_xxx" \
  "https://architectures-worker.vguruprasad91.workers.dev/api/stats"
Sample response
{
  "totalRepos": 127482,
  "totalPackages": 284,
  "totalMigrations": 1847,
  "lastUpdated": "2026-03-31T06:00:00Z",
  "ecosystems": ["npm", "pypi", "cargo", "go"]
}

Errors

The API uses standard HTTP status codes and returns structured JSON error bodies. Every error includes a machine-readable code field for programmatic handling.

Status Code Description
400 BAD_REQUEST Invalid parameters or malformed request
401 UNAUTHORIZED Missing or invalid API key
403 TIER_REQUIRED Feature requires Pro or Enterprise tier
404 NOT_FOUND Package or resource not found
429 RATE_LIMIT_EXCEEDED Too many requests for your tier
500 INTERNAL_ERROR Server error -- please report

Error response format

All errors follow this consistent structure:

Standard error response
{
  "error": "Rate limit exceeded",
  "message": "You've exceeded 60 requests/hour on the free tier",
  "code": "RATE_LIMIT_EXCEEDED",
  "upgrade_url": "https://architectures-app.pages.dev/register?plan=pro"
}
403 Tier-gated response
{
  "error": "Pro tier required",
  "message": "Historical data beyond 30 days requires a Pro subscription",
  "code": "TIER_REQUIRED",
  "required_tier": "pro",
  "upgrade_url": "https://architectures-app.pages.dev/register?plan=pro"
}
Handling errors in TypeScript
const response = await fetch(url, { headers });

if (!response.ok) {
  const err = await response.json();

  if (err.code === 'RATE_LIMIT_EXCEEDED') {
    const retryAfter = response.headers.get('Retry-After');
    await sleep(parseInt(retryAfter) * 1000);
    return retry(url);
  }

  if (err.code === 'TIER_REQUIRED') {
    console.log(`Upgrade: ${err.upgrade_url}`);
  }

  throw new Error(err.message);
}

MCP Integration

The Model Context Protocol (MCP) lets AI coding assistants like Claude Code, Cursor, and Windsurf access real-time adoption data as context when making recommendations. Instead of relying on training data that may be months old, your AI assistant queries live data from 127K+ repos.

Installation

Add the architectures MCP server to your claude_desktop_config.json or .cursor/mcp.json:

Available Tools

recommend_stack

Get data-backed stack recommendations for a use case

Example prompt: "Build me a real-time chat app"
compare_packages

Compare two packages head-to-head with live adoption data

Example prompt: "Should I use Prisma or Drizzle?"
check_adoption_trend

Check if a package is growing or declining in real repos

Example prompt: "Is Express still a good choice?"
get_cooccurrence

Find what commonly ships alongside a given package

Example prompt: "What pairs well with Hono?"
search_packages

Search by name or category across all tracked packages

Example prompt: "What's the best testing framework?"
claude_desktop_config.json
{
  "mcpServers": {
    "architectures": {
      "command": "npx",
      "args": ["-y", "architectures-mcp"]
    }
  }
}
Example conversation with Claude Code
// You:
Build me a serverless API with edge deployment

// Claude:
Let me check current adoption data for edge frameworks...
[Uses recommend_stack with use_case="serverless edge API"]

Based on real adoption data from 127K+ repos:

  Framework: Hono
  42% growth, 14KB bundle, 68% Cloudflare co-occurrence

  ORM: Drizzle
  67% growth, edge-native with SQLite/D1

  Validation: Zod
  56% market share, 72% co-occurrence with Hono

  Testing: Vitest
  35% growth, Vite-native

SDK / Client Libraries

While we work on official SDKs, here is a reference TypeScript client you can copy into your project. It handles authentication, rate limit retries, and provides typed responses for all endpoints.

Community SDKs

Have you built a client library? Open a PR to get it listed here.

architectures-client.ts
class ArchitecturesClient {
  private baseUrl = 'https://architectures-worker.vguruprasad91.workers.dev';

  constructor(private apiKey: string) {}

  private async request<T>(path: string): Promise<T> {
    const res = await fetch(
      `${this.baseUrl}${path}`,
      { headers: { Authorization: `Bearer ${this.apiKey}` } }
    );

    if (res.status === 429) {
      const retry = res.headers.get('Retry-After');
      await new Promise(r =>
        setTimeout(r, (parseInt(retry ?? '60') * 1000))
      );
      return this.request(path);
    }

    return res.json();
  }

  async trending(opts?: {
    category?: string;
    limit?: number;
  }) {
    const params = new URLSearchParams(
      opts as Record<string, string>
    );
    return this.request(
      `/api/trending?${params}`
    );
  }

  async compare(a: string, b: string) {
    return this.request(
      `/api/compare/${a}/${b}`
    );
  }

  async package(name: string) {
    return this.request(
      `/api/packages/${name}`
    );
  }

  async cooccurrence(name: string) {
    return this.request(
      `/api/cooccurrence/${name}`
    );
  }

  async search(q: string) {
    return this.request(
      `/api/search?q=${encodeURIComponent(q)}`
    );
  }
}

// Usage
const arch = new ArchitecturesClient('arch_xxx');
const data = await arch.trending({
  category: 'orm',
  limit: 5
});
Interactive

API Explorer

Try the API live — no signup required. Responses come from real data.

LIVE
No API key needed for Explorer
GET https://architectures-worker.vguruprasad91.workers.dev/api/trending
Click "Send Request" to try it
// Response will appear here
// Try clicking "Send Request" above

{
  "hint": "Select an endpoint and click Send Request",
  "tip": "All Explorer requests are free — no API key needed"
}
Enterprise

Batch API

Pull data for hundreds of packages in a single request. No more N+1 API calls.

Enterprise customers can query up to 500 packages in a single batch request, reducing latency and simplifying integration for large-scale analytics.

EndpointDescription
POST /api/batch/packagesFetch metadata for up to 500 packages in one call
POST /api/batch/compareRun up to 50 comparisons in parallel
POST /api/batch/cooccurrenceGet co-occurrence maps for up to 100 packages

Request Body

FieldTypeDescription
packagesstring[]Array of package names (max 500)
includestring[]Fields to include: ["stats", "adoption", "cooccurrence", "migrations"]
systemstringPackage system: npm, pypi, cargo, go
TypeScript
const response = await fetch('https://api.architectures.app/api/batch/packages', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer ' + API_KEY,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    packages: ['prisma', 'drizzle-orm', 'typeorm', 'sequelize', 'kysely'],
    include: ['stats', 'adoption', 'migrations'],
    system: 'npm'
  })
});

// Returns all 5 packages with full data in ~200ms
// vs 5 individual requests at ~150ms each = 750ms
Enterprise

Webhooks

Get notified in real-time when migration patterns change. Push alerts to Slack, PagerDuty, or any HTTP endpoint.

Available Events

EventTriggerUse Case
migration.detectedNew migration pattern exceeds thresholdAlert when repos start leaving your framework
migration.acceleratingExisting migration velocity increases >20%Early warning system for competitive threats
package.trendingPackage enters top-10 trendingTrack when your competitor starts gaining
package.decliningPackage growth turns negative for 3+ monthsIdentify risk in your dependency stack
cooccurrence.shiftMajor change in co-occurrence patternsDetect ecosystem shifts (e.g., React+Redux decoupling)

Webhook Payload

FieldTypeDescription
eventstringEvent type (e.g., migration.detected)
timestampstringISO 8601 timestamp
dataobjectEvent-specific payload
signaturestringHMAC-SHA256 signature for verification

Slack Integration

Point a webhook at your Slack incoming webhook URL. We format the payload as a rich Slack Block Kit message automatically.

Webhook Payload
{
  "event": "migration.accelerating",
  "timestamp": "2026-03-31T14:00:00Z",
  "data": {
    "from": "prisma",
    "to": "drizzle-orm",
    "previous_velocity": 34,
    "current_velocity": 47,
    "change_pct": 38.2,
    "repos_last_30d": 342,
    "direction": "accelerating",
    "category": "orm"
  },
  "signature": "sha256=a1b2c3..."
}
Configure Webhook
curl -X POST \
  -H "Authorization: Bearer arch_xxx" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://hooks.slack.com/services/T.../B.../xxx",
    "events": ["migration.accelerating", "package.declining"],
    "filters": {"packages": ["prisma", "drizzle-orm", "hono"]},
    "format": "slack"
  }' \
  https://api.architectures.app/api/webhooks
Enterprise

Data Export

Bulk download adoption data as CSV, JSON, or connect directly to your BigQuery dataset.

FormatEndpointDescription
CSVGET /api/export/csvFull dataset as CSV. Params: type (packages, migrations, cooccurrence), system, since
JSON LinesGET /api/export/jsonlStreaming JSONL format for large datasets. Supports cursor-based pagination.
BigQueryPOST /api/export/bigqueryLink your GCP project. We push a daily snapshot to your BigQuery dataset.
S3/R2POST /api/export/s3Daily snapshot pushed to your S3-compatible bucket (AWS S3, Cloudflare R2, MinIO).

Export Fields

Each export includes: package name, ecosystem, category, weekly downloads, repo count, stars, 12-month adoption curve, growth rate, co-occurrence pairs, and migration signals. Enterprise customers can request custom fields.

CSV Export
curl -H "Authorization: Bearer arch_xxx" \
  "https://api.architectures.app/api/export/csv?type=migrations&since=2026-01-01" \
  -o migrations.csv

# Output:
# from,to,velocity,repos_30d,direction,category
# prisma,drizzle-orm,47,342,accelerating,orm
# express,hono,31,218,accelerating,framework
# webpack,vite,28,891,steady,bundler
BigQuery Linked Dataset
curl -X POST \
  -H "Authorization: Bearer arch_xxx" \
  -H "Content-Type: application/json" \
  -d '{
    "gcp_project": "my-company-analytics",
    "dataset": "architectures_data",
    "schedule": "daily_2am_utc"
  }' \
  https://api.architectures.app/api/export/bigquery

# Then in BigQuery:
# SELECT * FROM my-company-analytics.architectures_data.migrations
# WHERE category = 'orm' AND velocity > 20
Enterprise

Enterprise MCP

Custom MCP server configured with your organization's tracked packages, private repos, and recommendation preferences.

The free MCP server uses our public dataset. Enterprise MCP lets you:

  • Track custom packages — internal libraries, private npm scopes, enterprise frameworks
  • Scan private repos — analyze adoption patterns across your GitHub org
  • Custom recommendation weights — bias toward your approved stack, flag deprecated tools
  • Team-wide deployment — single config for all developers' Claude Code / Cursor sessions

Additional MCP Tools (Enterprise)

ToolDescription
check_internal_adoptionAdoption trends for your org's internal packages across your repos
recommend_approved_stackLike recommend_stack but filtered to your org's approved package list
check_deprecation_riskFlags dependencies in a package.json that show declining adoption or security issues
compare_org_vs_industryCompare your org's tech choices against industry adoption patterns
Enterprise MCP Config
{
  "mcpServers": {
    "architectures-enterprise": {
      "command": "npx",
      "args": ["-y", "architectures-mcp"],
      "env": {
        "ARCH_API_KEY": "arch_enterprise_xxx",
        "ARCH_ORG": "my-company",
        "ARCH_APPROVED_ONLY": "true"
      }
    }
  }
}
Example Conversation
You: Check if our stack has any deprecation risks

Claude: [Uses check_deprecation_risk]

Warning: 2 packages in your stack show risk:

1. moment — declining -8.5%, last release 2022
   Recommended replacement: dayjs (+7.2% growth)

2. redux — declining -6.1%
   Your org's approved alternative: zustand (+28%)
Enterprise

Solutions

How companies use architectures.app at scale.

For Dev Tool Companies

Track your framework's adoption vs competitors in real codebases. Know exactly how many repos use your tool, what they pair it with, and whether developers are migrating toward or away from you.

Example: A database company tracks Prisma vs Drizzle adoption to inform their ORM integration strategy. Weekly Slack alerts notify when migration velocity changes.

For AI Coding Platforms

Embed real adoption data into your AI's stack recommendations. Instead of suggesting Express because it's in training data, recommend Hono because it's growing 43% and co-occurs with edge deployment in 68% of repos.

Example: A vibe coding platform uses the Batch API to pre-compute optimal stacks for 20 use case templates, refreshed daily.

For Engineering Leadership

Make stack decisions backed by data, not opinions. When your team debates "Prisma vs Drizzle," show the actual adoption curves, migration velocity, and which companies are switching. Arm your architects with facts.

Example: A CTO uses the Enterprise MCP to ensure all AI-generated code across 50 developers uses the team's approved stack.
Enterprise

SLA & Versioning

Stability guarantees for production integrations.

Service Level Agreement

MetricProEnterprise
Uptime99.5%99.9%
API response time (p95)<500ms<200ms
Data freshness6 hours2 hours (with GitHub token)
Support response48 hours4 hours (business hours)
Dedicated Slack channel
Custom onboarding

API Versioning

The current API version is v1. We follow semantic versioning:

  • Breaking changes — new version number, 12-month deprecation notice, migration guide
  • New fields — added without version bump (additive, non-breaking)
  • DeprecationsX-Deprecation-Notice header for 6 months before removal

Changelog

2026-03-31 — v1.4
Added Batch API, Webhooks, Data Export endpoints. Enterprise MCP tools.
2026-03-15 — v1.3
Added deps.dev integration. Python/Go/Rust ecosystem support.
2026-03-01 — v1.2
Added MCP server. Co-occurrence graph endpoint. Search improvements.
2026-02-15 — v1.0
Initial API release. 9 endpoints, JS/TS ecosystem.
Version Header
# Pin to a specific API version
curl -H "Authorization: Bearer arch_xxx" \
     -H "X-API-Version: 2026-03-31" \
     https://api.architectures.app/api/trending

# Response headers include:
# X-API-Version: 2026-03-31
# X-Deprecation-Notice: (if applicable)

Need more than 60 requests/hour?

Upgrade to Pro for $29/mo: full API access, 1,000 req/hr, 12-month historical data, all comparison pages, and migration alerts.