This repository is the official source of truth for the OpenAPI Specification (OAS), the industry-standard format for describing HTTP APIs. It is not a runtime application but rather a meticulously managed collection of specification documents, JSON Schema files, proposals, and the infrastructure tooling required to build, validate, and publish the specification. The repository's architecture is a monorepo for a standard, leveraging a shared build infrastructure package (`@oai/build-infra`) for tasks like markdown linting, HTML generation, and schema publication. Key entry points include the versioned specification files in `versions/`, the CI/CD workflows in `.github/workflows/`, and the governance documents. The primary data flow involves transforming Markdown specification sources into published HTML and JSON Schema artifacts. The repository demonstrates high craftsmanship in its governance model, branch management strategy (main/dev/release branches with automated syncing), and issue automation. It is actively maintained with a low technical drift risk, making it a model for how open standards should be managed. While the core content is a specification, the repository itself functions as an application of infrastructure tooling, with sophisticated CI/CD pipelines, test suites for schema validation and markdown rendering, and reusable scripts for branch management and issue lifecycle automation.
Kong is a cloud-native, platform-agnostic API gateway built on OpenResty/Nginx. It provides traffic management, security, observability, and AI/LLM proxying capabilities through a plugin architecture. The system supports traditional, DB-less, and hybrid deployment modes, with an Admin API for configuration and Kong Manager for GUI-based management. Key features include load balancing, authentication, rate limiting, request/response transformation, and extensive observability integrations.
This repository is a PHP implementation of the Pact contract testing framework, enabling consumer-driven contract testing for APIs and microservices. It allows developers to define expected interactions in consumer tests (generating Pact files) and verify provider compliance against those contracts. The library supports multiple transport protocols (HTTP/REST, gRPC, message queues) and data formats (JSON, XML, CSV, Protobuf, etc.) through a plugin architecture. It uses FFI to interface with a Rust-based Pact core and includes a mock server for simulating providers during testing. The codebase features a well-structured domain model, extensive matcher/generator system, and comprehensive compatibility suite validating adherence to Pact specifications v1-v4.
n8n is a production-grade workflow automation and AI agent platform. In production, it runs as a Node.js Express server with a Vue 3 frontend, executing user-defined workflows composed of nodes (triggers, actions, LLM calls). Workflows can be triggered manually, via webhooks, schedules, or events, and the execution engine handles concurrency, retries, errors, and data passing between nodes. The platform supports AI agents through an SDK that manages LLM calls, tool execution, memory, conversation loops, and MCP (Model Context Protocol) integration, enabling autonomous multi-step agents. Architecturally, the monorepo is organized into backend (packages/cli, packages/core, @n8n/engine), frontend (packages/frontend/editor-ui), database layer (@n8n/db with TypeORM), AI/agent packages (@n8n/agents, @n8n/ai-utilities, @n8n/instance-ai), and a vast node/credential library (packages/nodes-base, @n8n/nodes-langchain). Dependency injection is handled by @n8n/di, controllers are decorated with @RestController, and database models use a forked TypeORM. The system supports multiple database backends (PostgreSQL, SQLite) and can scale with Redis and worker processes. Key data flows: Workflow definitions are persisted in the database with version history. Execution data (inputs, outputs, binary data) is stored for monitoring and replay. The AI agent runtime uses a persistent message store for conversation memory, supports checkpoint/restore for long-running agents, and integrates with external LLMs (OpenAI, Anthropic, etc.) via a unified model factory. The platform exposes REST APIs for CRUD operations on workflows, credentials, users, and executions, as well as WebSocket push for real-time UI updates. External dependencies include a database, optional Redis for scaling, and numerous third-party services via nodes and credentials.
This repository is a community-curated directory of public APIs, organized by category in a single README.md file. Each entry includes the API name, description, authentication type, HTTPS support, and CORS status. The primary data artifact is the markdown file itself, which is manually maintained through pull requests. Supporting Python scripts validate the markdown format (alphabetical order, column padding, description length) and check that all listed API links are reachable, with special handling for Cloudflare-protected endpoints. The validation scripts are well-structured, parameterized, and include a comprehensive test suite, making them reusable for any similar markdown-based table validation. The repository is actively maintained with frequent commits and CI workflows, though its Python dependencies are slightly outdated (certifi 2021, requests 2.27.1). The core value is the curated dataset, not a software application.
This repository is a curated directory of public APIs, maintained as a human-readable Markdown table in `README.md` and automatically transformed into structured JSON files (`db/resources.json`, `db/categories.json`) via a Node.js generator. The primary data flow is: community contributions (PRs) update the README table → a GitHub Actions workflow runs `scripts/db/update-db.js` on every push to `main` → the script parses the Markdown using `remark-parse`, extracts categories and API entries, normalizes auth and CORS fields, and writes the JSON output back to the repository. The generated JSON serves as a machine-consumable API catalog for developers and tools (e.g., the companion website publicapis.dev). The repository is fundamentally a data_research project: its core value is the curated dataset of 1,800+ APIs with metadata (name, description, auth type, CORS support, category). The only 'application' component is the lightweight generator script and its utility modules, which are well-structured but tightly coupled to the specific Markdown format. There are no tests, no runtime services, and no external data sources beyond the README itself. The dataset is manually curated via pull requests, which introduces maintenance risks (stale links, incomplete metadata) but also ensures human oversight of quality. For reproducibility, an analyst can clone the repo, run `npm install` (dependencies are locked via `package-lock.json`), and execute `npm run build` to regenerate the JSON from the README. The entire pipeline is self-contained and does not require external credentials or data. However, the lack of unit tests means that changes to the parsing logic could silently break the output.
WSO2 API Manager is an enterprise-grade API management platform. In production, it provides API publishing, a developer portal, a gateway for request mediation/security enforcement (authentication, rate limiting, threat protection), a key manager (OAuth2, JWT, API keys), and a traffic manager for analytics and throttling. The architecture is modular, with deployable profiles (all-in-one, control-plane, gateway, traffic-manager) built on the WSO2 Carbon kernel with Apache Synapse mediation. The codebase is primarily Java/Maven with Python-based recommendation engine components, extensive integration tests (both legacy TestNG and a modern Cucumber/Testcontainers parallel framework), and sample scenarios. Key entry points include REST APIs (Publisher, Developer Portal, Admin, Gateway), startup scripts (api-manager.sh), and deployment configuration (deployment.toml). External dependencies include WSO2 Identity Server for key management, databases (H2/PostgreSQL), MongoDB for recommendations, and various protocols (REST, GraphQL, WebSocket, SSE, WebSub, SOAP, MCP).
Integuru is a Python application that reverse-engineers API requests from browser traffic to generate runnable integration code. It takes a HAR file (HTTP archive) containing browser network requests and cookie data, then uses LLMs to analyze these requests to identify which endpoint performs a user-specified action. The system builds a dependency graph to determine what prerequisite requests are needed to gather dynamic parameters (like IDs, tokens), and finally generates Python code that can reproduce the action by making the necessary HTTP requests in the correct order. The architecture uses LangGraph for workflow orchestration, with specialized LLM-powered agents handling different aspects of the analysis (URL identification, dynamic parameter extraction, dependency resolution).