# What Programming Language Is Open‑SEO Written In?

> Discover the programming language behind Open-SEO. This powerful tool is written entirely in TypeScript, running on Cloudflare Workers and Node.js.

- Repository: [Every App/open-seo](https://github.com/every-app/open-seo)
- Tags: getting-started
- Published: 2026-09-11

---

**Open‑SEO is authored entirely in TypeScript, the statically‑typed superset of JavaScript, compiling to run on both Cloudflare Workers and Node.js environments.**

The every‑app/open‑seo repository is a modern SEO platform built with type safety as a core architectural principle. According to the source code, the project leverages TypeScript across its entire stack—from server functions to database schemas—to ensure robust tooling and compile‑time error checking.

## Evidence from the Source Code

Examining the repository root reveals immediate indicators of TypeScript authorship. The presence of **[`tsconfig.json`](https://github.com/every-app/open-seo/blob/main/tsconfig.json)** at the project root configures the TypeScript compiler with strict type‑checking rules. Additionally, **[`package.json`](https://github.com/every-app/open-seo/blob/main/package.json)** explicitly declares `"typescript": "^5.9.3"` as a development dependency, confirming the version used to build the application.

The codebase structure contains dozens of `.ts` files rather than plain JavaScript. For example, **[`src/serverFunctions/keywords.ts`](https://github.com/every-app/open-seo/blob/main/src/serverFunctions/keywords.ts)** implements server‑side logic using TypeScript interfaces and type annotations. This pattern repeats across the codebase, with files like **[`src/shared/gsc.ts`](https://github.com/every-app/open-seo/blob/main/src/shared/gsc.ts)** (Google Search Console integration) and **[`src/db/schema.ts`](https://github.com/every-app/open-seo/blob/main/src/db/schema.ts)** (database definitions) all bearing the `.ts` extension and containing strongly‑typed code.

## Key TypeScript Implementation Patterns

The Open‑SEO codebase employs modern TypeScript patterns including async/await syntax and runtime type validation. Below is a representative example mirroring the style found in [`src/serverFunctions/keywords.ts`](https://github.com/every-app/open-seo/blob/main/src/serverFunctions/keywords.ts):

```ts
// src/serverFunctions/example.ts
import { z } from "zod";

/** Input schema for the example endpoint */
const InputSchema = z.object({
  domain: z.string().url(),
});

/** Example server function */
export async function getExampleData(input: z.infer<typeof InputSchema>) {
  // Simulated asynchronous operation
  const response = await fetch(`https://api.example.com/seo?url=${input.domain}`);
  const data = await response.json();
  return data;
}

```

This snippet demonstrates two critical patterns used throughout Open‑SEO:

- **Zod integration** for runtime type safety, where `z.infer<typeof InputSchema>` extracts static TypeScript types from validation schemas.
- **ES Module exports** with explicit return type inference, allowing the compiler to verify data shapes before deployment.

## Critical TypeScript Files in the Repository

Understanding the codebase structure requires examining specific files that define the TypeScript architecture:

- **[`tsconfig.json`](https://github.com/every-app/open-seo/blob/main/tsconfig.json)** — Configures compiler options including target environment and module resolution for the entire project.
- **[`package.json`](https://github.com/every-app/open-seo/blob/main/package.json)** — Declares TypeScript `^5.9.3` alongside related tooling dependencies.
- **[`src/serverFunctions/keywords.ts`](https://github.com/every-app/open-seo/blob/main/src/serverFunctions/keywords.ts)** — Contains server‑side business logic written entirely in TypeScript with typed function signatures.
- **[`src/shared/gsc.ts`](https://github.com/every-app/open-seo/blob/main/src/shared/gsc.ts)** — Implements Google Search Console API interactions using strongly‑typed interfaces.
- **[`src/db/schema.ts`](https://github.com/every-app/open-seo/blob/main/src/db/schema.ts)** — Defines database schemas using Drizzle ORM with TypeScript type definitions.

## Runtime Compilation Target

While the source is written in TypeScript, the application compiles to JavaScript for execution. The repository configuration targets **Cloudflare Workers** and **Node.js** environments. The [`tsconfig.json`](https://github.com/every-app/open-seo/blob/main/tsconfig.json) settings ensure compatibility with these runtimes while preserving type safety during development.

## Summary

- Open‑SEO is written entirely in **TypeScript**, not plain JavaScript.
- The repository uses **TypeScript 5.9.3** as declared in [`package.json`](https://github.com/every-app/open-seo/blob/main/package.json).
- Source files use the `.ts` extension, including critical paths like [`src/serverFunctions/keywords.ts`](https://github.com/every-app/open-seo/blob/main/src/serverFunctions/keywords.ts) and [`src/db/schema.ts`](https://github.com/every-app/open-seo/blob/main/src/db/schema.ts).
- The codebase employs **Zod** for runtime validation combined with static type inference.
- TypeScript compiles to JavaScript for deployment on **Cloudflare Workers** and Node.js.

## Frequently Asked Questions

### Is Open‑SEO built with JavaScript or TypeScript?

Open‑SEO is built with **TypeScript**. While it runs as compiled JavaScript in production, every source file in the repository uses the `.ts` extension and includes type annotations. The [`tsconfig.json`](https://github.com/every-app/open-seo/blob/main/tsconfig.json) file enforces strict type checking, making TypeScript the primary development language.

### What version of TypeScript does Open‑SEO use?

The repository specifies **TypeScript ^5.9.3** in its [`package.json`](https://github.com/every-app/open-seo/blob/main/package.json) dependency list. This version provides the latest language features and compiler optimizations used throughout the server functions and database schema definitions.

### How does Open‑SEO handle database operations in TypeScript?

Database operations use **Drizzle ORM** with TypeScript type definitions. The file [`src/db/schema.ts`](https://github.com/every-app/open-seo/blob/main/src/db/schema.ts) contains strongly‑typed schema definitions that provide autocomplete and compile‑time verification for all database queries, ensuring type safety from the application layer to the data layer.

### Where does Open‑SEO deploy its compiled TypeScript code?

The TypeScript codebase compiles to JavaScript for deployment on **Cloudflare Workers** and **Node.js** environments. The [`tsconfig.json`](https://github.com/every-app/open-seo/blob/main/tsconfig.json) configuration targets these specific runtimes, enabling edge computing deployment while maintaining a single TypeScript source of truth.