Engineering teams·MCP·Governance + Audit

One MCP server for your entire API ecosystem.

Stop the fragmentation: different MCP servers, direct APIs, and ad-hoc CLI tooling across the team. APIFunnel is the governed conduit for agent access—unified auth, policy controls, and auditability.

IDE setup guide

Get started

3 quick steps. Sign in only if needed.

MCP Server URL

https://tool.apifunnel.ai/mcp/

Configure your IDE

Paste config and restart

Connect it to your IDE in 60 seconds.

Copy a small config file, paste your token, and restart. For a step-by-step guide, use the setup page.

Open IDE setup Security + setup FAQ

Example: Cursor (~/.cursor/mcp.json)

{
  "mcpServers": {
    "apifunnel": {
      "url": "https://tool.apifunnel.ai/mcp/",
      "headers": {
        "Authorization": "Bearer YOUR_TOKEN_HERE"
      }
    }
  }
}

One conduit to engineering + product APIs.

Standardize access to the tools engineers actually use day-to-day—then expand to the rest of the org as needed.

Documentation

GitHub

Jira

Atlassian

Linear

Asana

Monday.com

Notion

Slack

Sentry

PagerDuty

Datadog

GitLab

Bitbucket

Don't see what you need? Request an integration from inside the dashboard—fast turnaround.

Reduce sprawl. Increase control.

This is the exact problem: teams adopt agency fast, but integrations fragment. APIFunnel makes it one standard surface.

Before: fragmented tool surface

Different choices per engineer → inconsistent governance

▸Multiple MCP servers for the same provider

▸Some direct APIs, some CLI, some wrappers

▸Secrets scattered across envs, repos, laptops

▸No single audit boundary for "agent did X"

After: one governed conduit

Standardize once; scale agency safely

▸One MCP server for the whole team

▸Unified auth + scoped permissions

▸Central policy controls + rate limiting

▸Audit + observability across tools and sandboxes

Built for engineering orgs.

Adopt agency without creating an ungoverned integration sprawl. APIFunnel is the standard interface layer for agent access to third-party APIs.

Skills (hosted)

Persisted, shareable building blocks in the cloud

Compile + publish immutable skills

Per-user storage + artifacts for long-lived reuse

Turn proven sequences into team standards

Scheduling

Run skills/workflows unattended on cron

Scheduled jobs with retries

On-demand runs for incident response

From "prompt" to reliable automation

Governance

One security boundary to review and enforce

Centralized auth and scoped permissions

Policy controls and least-privilege patterns

Audit trails for agent-driven actions

Discovery

Find capabilities at runtime, not in docs tabs

Tool discovery and schema inspection

Progressive integration onboarding

Less brittle workflows as APIs evolve

Standardization

One interface across Slack, Jira, GitHub, and beyond

Reduce duplicate integrations across teams

Consistent calling patterns and naming

Fewer "pet" MCP servers to maintain

Observability

Know what agents did, where, and why

Unified execution surface (tools + sandboxes)

Audit-friendly records of actions

Operational visibility for incidents

How APIFunnel Works

End-to-end architecture: From your IDE to 50+ integrated services

Your IDE

Entry point

Cursor, Claude Desktop, Windsurf, GPT Apps, Perplexity, or any MCP-compatible platform

// AI Assistant writes code using discovered APIs

from gmail_api import send_message

from github_api import create_issue

from slack_api import post_message

MCP protocol (JSON-RPC over HTTP/SSE)

APIFunnel MCP Bridge Server

Core platform

The central hub connecting your IDE to 50+ services with zero configuration

1. Discovery Layer

Progressive API discovery with real-time schema inspection

▸list_api_servers() → 50+ integrations

▸tools_search() → Find capabilities

▸get_tool_info() → Full schemas

2. Execution Layer

Isolated sandbox environments for Python and browser automation

Python Sandbox

▸Podman containers

▸OAuth auto-injection

▸Session persistence

▸Artifact storage

Browser Sandbox

▸Playwright automation

▸Visual snapshots

▸Element labeling

▸Multi-step workflows

3. Skills Layer

Reusable workflows

Compile, test, publish, and schedule persistent workflows

▸skills_compile() → Validate & test

▸skills_publish() → Persist immutably

▸skill_schedule() → Cron automation

▸skill_run_now() → On-demand execution

4. Persistence Layer

Secure, encrypted storage with automatic lifecycle management

▸User OAuth tokens (encrypted)

▸Published skills (MongoDB + S3)

▸Scheduled jobs (AWS Fargate)

▸Per-user namespacing

External API calls (per-user OAuth)

External Services

50+ integrations

Plug-and-play server configurations maintained by APIFunnel. Full OpenAPI specs, OAuth flows, and token management—all handled internally so you don't have to.

GmailSlackGitHubJiraSalesforceHubSpotAirtableLinearNotionAsanaTrelloZendeskIntercomStripeTwilio+ 35 more

Don't see your integration? Sign in to request new integrations.

Get Started Free

Workflows are a hosted service.

Skills persist in the cloud. Workflows wire skills together. You can run them on-demand or schedule them like a job runner—while still combining API orchestration and browser automation when needed.

▸Tasks: real-time execution

▸Skills: saved, componentized tasks

▸Workflows: skills wired into a cohesive process

Build your first skill Security + scheduling FAQ

Viewer

No content to display

Workflow Engine: Discovery → Execution → Persistence

A single conduit to APIs + hosted skills + schedulable workflows

Pricing

Get started free and help shape the roadmap.

Security + architecture FAQ

Ready to wire it into your IDE?

Copy the config, connect once, and standardize access for every engineer and every agent.

Open IDE setup View docs

Workflows are a hosted service.

▸Tasks: real-time execution

▸Skills: saved, componentized tasks

▸Workflows: skills wired into a cohesive process