Open-SEO Dependencies: Complete Guide to Runtime and Dev Dependencies

Open-SEO dependencies include React 19, TanStack libraries, Drizzle ORM, Cloudflare Workers SDK, and Vite tooling for a full-stack TypeScript SEO platform.

The open-source open-seo repository is a modern full-stack TypeScript application designed to run on Cloudflare Workers with Vite-powered frontend tooling. Understanding its dependency structure is essential for contributors, security auditors, and developers evaluating the stack for similar projects. All dependencies are declared in the root package.json and organized across runtime production packages and development tooling.

Core UI and State Management Dependencies

The frontend architecture relies on the TanStack ecosystem paired with React 19 and Tailwind CSS for styling.

Dependency	Purpose	Location in package.json
react / react-dom	UI component rendering	Lines 77-78
@tanstack/react-router	Type-safe client-side routing	Line 79
@tanstack/react-query	Server state synchronization and caching	Line 80
@tanstack/react-form	Form state management	Line 81
@tanstack/react-table	Data table rendering	Line 82
tailwindcss	Utility-first styling	Line 93

These packages enable server-side rendering with client-side hydration via @tanstack/react-start, which coordinates the React Router and Query integration for optimal SEO performance.

Data and Backend Dependencies

Database connectivity and Cloudflare-native services form the backend foundation.

• Drizzle ORM – Type-safe SQL builder supporting both drizzle-orm/pg-core for Postgres and SQLite variants
• @cloudflare/workers-oauth-provider – Authentication middleware for Cloudflare Workers
• @cloudflare/ai-chat – AI chat integration for the platform
• @every-app/sdk – Internal SDK for core business logic

These appear in package.json lines 94-102 and are consumed throughout the src/db/ directory, particularly in src/db/pg/better-auth-schema.ts where the Drizzle schema is defined.

Third-Party API Integration Dependencies

Open-SEO connects to external SEO and AI services through specialized clients:

• dataforseo-client – DataForSEO API integration for keyword research and rank tracking
• @modelcontextprotocol/* – Model Context Protocol implementations for AI tool calling
• @openrouter/ai-sdk-provider – OpenRouter AI model access

Reference these in package.json lines 103-108. The project includes a utility script that demonstrates DataForSEO usage:

{
  "scripts": {
    "billing:usage": "tsx scripts/dataforseo-account-usage.ts"
  }
}

Utility Dependencies

Supporting libraries handle specialized data processing tasks:

• zod – Runtime schema validation throughout the API layer
• remeda – Functional programming utilities
• papaparse – CSV import/export for bulk SEO data
• fast-xml-parser / htmlparser2 – SERP and sitemap parsing
• tldts – Top-level domain extraction
• jose – JWT signing and verification for Better-Auth
• posthog-node / posthog-js – Product analytics
• lucide-react – Consistent icon system

These packages appear in package.json lines 109-121 and are imported across route handlers and UI components.

Development Dependencies

The build and quality toolchain includes:

Tool	Purpose
vite / @vitejs/plugin-react	Module bundling and React Fast Refresh
@cloudflare/vite-plugin	Cloudflare Workers preview integration
typescript	Type checking across the monolith
oxlint	Fast JavaScript/TypeScript linting
prettier	Code formatting
knip	Unused dependency detection
vitest	Unit testing framework
playwright	End-to-end browser testing
wrangler	Cloudflare Workers deployment CLI
alchemy	Infrastructure-as-code for Cloudflare
tsx	TypeScript execution for scripts

Code Examples: Dependencies in Practice

TanStack React Query for SEO Data Fetching

import { useQuery } from '@tanstack/react-query';
import { getKeywordStats } from '@every-app/sdk';

export function KeywordStats({ keyword }: { keyword: string }) {
  const { data, isLoading, error } = useQuery(
    ['keyword-stats', keyword],
    () => getKeywordStats(keyword),
    { staleTime: 5 * 60_000 }
  );

  if (isLoading) return <>Loading…</>;
  if (error) return <>Error loading stats</>;

  return (
    <div>
      <h2>{keyword}</h2>
      <p>Search volume: {data?.searchVolume}</p>
      <p>Difficulty: {data?.difficulty}</p>
    </div>
  );
}

Drizzle ORM Query in Cloudflare Worker

import { db } from '@/db/pg/better-auth-schema';
import { eq } from 'drizzle-orm/pg-core';
import { users } from '@/db/pg/schema';

export async function getUserById(id: string) {
  const result = await db.select().from(users).where(eq(users.id, id));
  return result[0] ?? null;
}

Key Configuration Files

Understanding these dependencies requires familiarity with their configuration:

• package.json – Canonical source of all dependency declarations
• tsconfig.json – TypeScript compiler options and path mapping
• vite.config.ts – Vite plugin configuration including Cloudflare integration
• wrangler.toml – Cloudflare Workers deployment settings
• src/db/pg/better-auth-schema.ts – Drizzle ORM schema instantiation
• src/app.tsx – Application entry point that imports React and TanStack providers

Summary

• Open-SEO dependencies span React 19, TanStack libraries, Drizzle ORM, and Cloudflare SDKs for a complete full-stack architecture
• Frontend dependencies prioritize type-safe routing and server state management via TanStack
• Backend dependencies focus on edge-native database access through Drizzle and Cloudflare Workers
• External API dependencies integrate DataForSEO, OpenRouter, and Model Context Protocol for core SEO functionality
• Development dependencies emphasize fast feedback via Vite, strict quality via Oxlint/Prettier, and reliable deployment via Wrangler

Frequently Asked Questions

What is the main frontend framework in open-seo?

React 19 is the core UI library, paired with TanStack React Router for routing and TanStack React Query for data fetching. This combination replaces traditional meta-frameworks with a modular, type-safe architecture optimized for Cloudflare's edge runtime.

Does open-seo use a traditional Node.js backend?

No. Open-SEO uses Cloudflare Workers as its runtime, executing at the edge rather than on centralized Node.js servers. The backend logic runs through Vite's bundling pipeline with the @cloudflare/vite-plugin for local development parity.

How does open-seo handle database operations?

Database access uses Drizzle ORM with support for both Postgres (via drizzle-orm/pg-core) and SQLite. The schema definitions in src/db/pg/better-auth-schema.ts demonstrate type-safe table definitions and query building that compile to efficient SQL for the Workers environment.

What external SEO services does open-seo integrate with?

The platform integrates DataForSEO for keyword and ranking data, OpenRouter for AI model access, and Model Context Protocol providers for extended AI capabilities. These are consumed through dedicated client packages listed in package.json lines 103-108.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}