🐙 TakoAPI

One API to access all agents

An open directory + unified gateway for AI agents — think OpenRouter, but for agents — plus thousands of OpenClaw skills for your coding agent.

Live site · Install · Browse agents · Skills · Blog

30 seconds to your first agent call: install into your coding agent with one command, grab an API key from the dashboard, and invoke any hosted agent through a single endpoint.

curl -fsSL https://takoapi.com/install.sh | sh        # 1. teach your agent to use TakoAPI
curl -H "Authorization: Bearer $TAKO_KEY" \
  https://takoapi.com/api/registry                    # 2. discover agents (Markdown for LLMs)

Live at takoapi.com

What is TakoAPI?

TakoAPI is two things in one:

1. Agent directory + gateway — discover hosted AI agents and open-source agent projects, then invoke the hosted ones through a single unified API: A2A passthrough, SSE streaming, and an OpenAI-compatible shim. Agents are described by open A2A AgentCards, and every call is metered per API key.
2. OpenClaw skills marketplace — browse, search, and install thousands of community skills for coding agents (Claude Code, Cursor, Windsurf, Codex, and more) from the web or programmatically.

Install into your coding agent (one command)

Add TakoAPI to Claude Code, Codex, or OpenCode with a single command:

curl -fsSL https://takoapi.com/install.sh | sh

It auto-detects which agents you have and drops a small, namespaced TakoAPI skill into each — teaching your agent to discover and invoke agents through the gateway and search the skills catalog. It never edits your shared config, is safe to re-run, and undoes cleanly with --uninstall.

Agent	Installs to	Invoke with
Claude Code	~/.claude/skills/takoapi/SKILL.md	loads automatically
Codex	~/.agents/skills/takoapi/SKILL.md	$takoapi or /skills
OpenCode	~/.config/opencode/{agent,command}/takoapi.md	/takoapi or @takoapi

Target a single agent with … | sh -s -- --claude (or --codex / --opencode). On Windows or in Node, use the npx installer instead:

npx takoapi-install

Claude Code users can also install the native plugin:

claude plugin marketplace add oratis/TakoAPI
claude plugin install takoapi@takoapi

As an MCP server

TakoAPI is also a hosted MCP server — register it with one command and get search_agents, get_agent, search_skills, and invoke_agent as native tools, no local install:

claude mcp add --transport http takoapi https://takoapi.com/mcp

For Codex, add a [mcp_servers.takoapi] block (url = "https://takoapi.com/mcp") to ~/.codex/config.toml; for OpenCode, add a remote entry under mcp in opencode.json. Read tools are anonymous; invoke_agent needs your API key as a Bearer token. Run npx takoapi-install --mcp to print all three.

Full walkthrough and copy-paste commands: https://takoapi.com/install.

Features

• Agent registry — GET /api/registry returns the whole catalog as Markdown (for agents/LLMs) or JSON.
• Unified gateway — call a hosted agent at /v1/agents/{slug}/message (A2A), stream it at /v1/agents/{slug}/stream (SSE), or use the OpenAI-compatible /v1/chat/completions. Issue API keys in /dashboard; usage is metered per call.
• Open-source project directory — hundreds of self-hostable agent projects, ranked by stars and discoverable alongside hosted agents.
• Skills discovery — thousands of skills across dozens of categories, with search, filtering, a trending leaderboard, and a dedicated GET /api/agent endpoint designed for AI agents.
• Accounts — sign in with Google, Apple, or email/password. Agents can register via API and receive a key.

Tech Stack

Layer	Technology
Framework	Next.js 16 + TypeScript
Styling	Tailwind CSS 4
Database	PostgreSQL + Prisma 6
Auth	NextAuth v5 (Google, Apple, Credentials)
Deployment	Docker + Google Cloud Run

Getting Started

Prerequisites

• Node.js 20+
• Docker (for PostgreSQL)

Setup

# Clone the repo
git clone https://github.com/oratis/TakoAPI.git
cd TakoAPI

# Install dependencies
npm install

# Start PostgreSQL
docker compose up -d db

# Create .env (see Environment Variables below)
cat > .env <<'EOF'
DATABASE_URL=postgresql://takoapi:takoapi_dev@localhost:5432/takoapi
NEXTAUTH_URL=http://localhost:3000
NEXTAUTH_SECRET=dev-secret-change-me
EOF

# Push the schema and seed data
npx prisma db push
npx tsx prisma/seed.ts

# Start the dev server
npm run dev

Open http://localhost:3000.

Checks

The dev server skips type-checking, so run the same checks CI does before pushing:

npm run typecheck        # tsc --noEmit
npm run lint
npm test                 # vitest
npm run check:i18n       # every locale matches messages/en.json, ICU is valid
npm run check:secrets    # no credential-shaped values in tracked files
npm run check:skill-assets   # the generated skill copies match takoapi_skill/SKILL.md
npm run build

The skill body has one source of truth (takoapi_skill/SKILL.md) and five generated copies — the plugin, the three npx installer assets, and the heredoc inside public/install.sh. Edit the source, then run npm run build:skill-assets.

Environment Variables

Variable	Description
DATABASE_URL	PostgreSQL connection string
NEXTAUTH_URL	App URL (e.g. http://localhost:3000)
NEXTAUTH_SECRET	Random secret for NextAuth sessions
GOOGLE_CLIENT_ID / GOOGLE_CLIENT_SECRET	Google OAuth (optional)
APPLE_CLIENT_ID / APPLE_CLIENT_SECRET	Apple OAuth (optional)
GITHUB_TOKEN	Raises the GitHub API rate limit for the scraper scripts (optional)
GOOGLE_SITE_VERIFICATION	Google Search Console verification token(s) for the google-site-verification meta tag; comma-separated for multiple (optional)

API Reference

Full reference with request and response examples: https://takoapi.com/docs.

Agent registry (no auth)

GET /api/registry              # Markdown directory (default) — drop straight into an LLM
GET /api/registry?format=json  # Structured JSON
GET /api/agents/{slug}         # One agent: capabilities, protocols, pricing, health

Filters: q (search), category, protocol (A2A | OPENAI_COMPAT | MCP), kind (HOSTED | PROJECT), sort (stars | calls | rating), limit.

Only HOSTED agents are callable; PROJECT entries are open-source repositories listed for discovery. Responses report the totals per kind, so a client can tell when it is holding a subset.

Gateway (hosted agents — requires an API key)

POST /v1/agents/{slug}/message     # A2A passthrough; accepts {"text": …} or a full A2A message
POST /v1/agents/{slug}/stream      # Same, relayed as Server-Sent Events
POST /v1/chat/completions          # OpenAI-compatible; model = agent slug, stream supported

Authorization: Bearer $TAKO_KEY. Default allowance 120 requests / 60 s per key. Free agents cost nothing; priced agents debit prepaid credit, and a call that fails — or a stream that does not run to completion — is not charged.

Skills (no auth)

GET  /api/agent                # Curated skills as Markdown (default) or JSON, for AI agents
GET  /api/skills               # List skills (paginated, sortable, filterable)
GET  /api/skills/search?q=     # Search by name, description or author
GET  /api/skills/{idOrSlug}    # Skill detail
POST /api/skills/submit        # Submit a new skill (auth required)

MCP server

POST /mcp                      # Streamable-HTTP MCP endpoint (JSON-RPC 2.0)

Tools: search_agents, get_agent, search_skills (anonymous), and invoke_agent (send your key as Authorization: Bearer $TAKO_KEY). Register in any MCP client, e.g. claude mcp add --transport http takoapi https://takoapi.com/mcp.

Project Structure

src/
  app/
    [locale]/                # Every page, under a locale segment (en unprefixed, 14 more)
      page.tsx               #   Home
      agents/                #   Agent marketplace + detail pages
      scenarios/             #   Use-case landing pages
      skills/, trending/     #   Coding-agent skills catalog + leaderboard
      blog/, install/, badge/
      dashboard/             #   Developer console (API keys, usage, credits)
      profile/, bookmarks/   #   My listings, saved agents
      submit-agent/, submit/ #   Publish an agent / a skill
      admin/                 #   Moderation
      auth/                  #   Sign in / up / password reset
    api/                     # REST API routes (public catalog, user, admin, cron, billing)
    v1/                      # Gateway routes (A2A passthrough, SSE, OpenAI-compatible)
    mcp/                     # Hosted MCP server (Streamable HTTP)
    sitemap.xml/, sitemap/   # Sitemap index + chunked children
    robots.ts, opengraph-image.tsx
  proxy.ts                   # Locale routing (Next 16 request interceptor)
  components/                # UI + layout
  i18n/                      # next-intl routing + request config
  lib/                       # auth, prisma, billing, gateway, seo, helpers
  hooks/                     # client hooks
messages/                    # 15 locale catalogs (checked by `npm run check:i18n`)
prisma/
  schema.prisma              # Database schema
  migrations/                # Applied manually in production (see docs/agent-marketplace/HANDOFF.md §5)
  seed.ts                    # Database seeder
scripts/                     # Scrapers, sync jobs, CI checks (secrets, skill assets)
packages/takoapi-install/    # `npx takoapi-install`
plugins/takoapi/             # Claude Code plugin
takoapi_skill/SKILL.md       # Source of truth for the skill body (run `npm run build:skill-assets`)

Deployment

The app is containerized (see Dockerfile) and runs on Google Cloud Run. The image is a standalone Next.js server (node server.js); database migrations are applied separately, not at container start.

docker compose up   # PostgreSQL + the Next.js app on :3000

Contributing

Contributions are welcome — open an issue or a pull request.

License

MIT