Skip to main content

​
What It Does

Your application integrates with external services: Stripe for payments, Auth0 for authentication, SendGrid for emails, Twilio for SMS. These aren’t infrastructure you run - they’re third-party APIs your code depends on. Monk can orchestrate any resource with a lifecycle and an API. This means Monk doesn’t just detect that you’re using Stripe - it provisions Stripe resources (products, webhooks, API keys), injects credentials into your application, and updates webhook URLs when your deployment changes. Monk keeps a complete map of your system, including abstract resources managed by third-party providers. You provide credentials once and authorize Monk to work with these APIs. Monk handles the rest throughout your application’s lifecycle.

​
How It Works

​
API Orchestration & Lifecycle Management

Monk treats third-party APIs as first-class resources it can orchestrate, just like it manages containers and cloud infrastructure. What Monk can do with APIs:
  • Provision resources - Create Auth0 applications, Stripe products, webhooks, API keys
  • Obtain secrets - Retrieve API keys, client secrets, tokens automatically
  • Inject credentials - Add them to your application’s configuration securely
  • Update endpoints - Change webhook URLs, callback URLs as deployments move
  • Manage lifecycle - Update, reconfigure, or remove API resources as needed
  • Track relationships - Understands which services depend on which APIs
Example: Auth0 Integration
  1. During code analysis, Monk detects Auth0 SDK usage
  2. You provide Auth0 management API credentials
  3. Monk provisions an Auth0 application for your deployment
  4. Monk obtains client ID and client secret
  5. Monk configures callback URLs based on your deployment (e.g., https://yourapp.com/auth/callback)
  6. Monk injects credentials into your application via Configuration & Wiring
  7. When you redeploy or move clouds, Monk updates the callback URL automatically
Example: Stripe Integration
  1. Monk detects Stripe SDK usage in your code
  2. You provide Stripe API credentials
  3. Monk creates webhook endpoints in Stripe pointing to your API
  4. Monk configures webhook signing secrets
  5. Monk injects Stripe publishable and secret keys into frontend/backend
  6. When you scale or redeploy, Monk updates webhook URLs to match new infrastructure

​
Automatic API Detection

During code analysis, Monk identifies third-party API integrations: What Monk discovers:
  • API SDKs and client libraries (Stripe, Auth0, SendGrid, Twilio, etc.)
  • API key references in environment variables
  • Webhook handlers and callback endpoints in your code
  • OAuth flows and redirect URLs
  • API-specific configuration needs
Monk understands your API dependencies before you configure anything.

​
Unified System Map

Traditional approaches require managing third-party services through separate dashboards:
  • Stripe dashboard for payment configuration
  • Auth0 dashboard for authentication setup
  • AWS console for cloud resources
  • Cloud provider dashboards for databases
  • DNS provider for domain management
Monk maintains a complete system map:
  • Your containers and code (what you built)
  • Cloud infrastructure (where it runs)
  • Databases and Essential Services (supporting infrastructure)
  • Third-party API resources (external dependencies)
  • Relationships between all components
You get a single view of your entire system - not scattered across dozens of provider dashboards.

​
Dynamic Configuration Updates

When your deployment location or structure changes, API configurations need to update: Monk handles automatically:
  • Webhook URLs - Updated when API server IP/domain changes
  • OAuth callback URLs - Updated when frontend domain changes
  • CORS origins - Updated to match current frontend URLs
  • API endpoint references - Updated when service URLs change
  • Webhook signing secrets - Rotated and redistributed securely
Traditional approach: 
1. Deploy application to new server
2. Note new server IP/domain
3. Log into Stripe dashboard
4. Manually update webhook URL
5. Log into Auth0 dashboard
6. Manually update callback URLs
7. Update environment variables with new URLs
8. Redeploy application with new config
With Monk: 
1. Deploy application to new location
   (Monk updates all API configurations automatically)

​
Authorization & Credentials

To enable API orchestration, you authorize Monk to work with third-party services: What you provide:
  • API credentials for each service (API keys, OAuth tokens, management API access)
  • Authorization to manage resources on your behalf
What Monk does:
  • Provisions and configures API resources
  • Obtains necessary secrets automatically
  • Stores credentials securely (see Security)
  • Updates configurations throughout lifecycle
Your credentials stay secure - They’re stored on your side, never exposed to the LLM, and never sent to Monk servers. See Security for details. Monk needs these because it manages your accounts with third-party providers on your behalf (Bring Your Own Infrastructure - BYOI).

​
Supported API Integrations

Monk supports several third-party API providers via integrations: Identity & Authentication:
  • Auth0
  • AWS Cognito
  • AWS IAM
Payments:
  • Stripe (payment processing, subscriptions, webhooks)
And many more via the integrations ecosystem. Don’t see your API? Let us know - Monk’s integration ecosystem is constantly growing. Any API with a management interface can potentially be orchestrated by Monk.

​
Practical Example

​
Authentication with Auth0

Your application: SaaS app with Auth0 login What Monk orchestrates:
  1. Detects Auth0 SDK usage
  2. Asks for Auth0 management API credentials
  3. Creates Auth0 application for your deployment
  4. Configures allowed callback URLs (https://yourapp.com/auth/callback)
  5. Configures allowed logout URLs
  6. Obtains client ID and secret
  7. Injects into application config
  8. When frontend domain changes (e.g., staging to production), updates callback URLs automatically
Your code just initiates Auth0 login - Monk handles application setup, callbacks, and credential injection.

​
What Makes This Different

Traditional third-party API integration requires:
  • Manually creating applications/resources in provider dashboards
  • Copying API keys and secrets into environment variables
  • Configuring webhook URLs and callback URLs manually
  • Updating configurations when deployments change
  • Managing secrets across environments
  • Remembering which dashboard has which setting
  • Coordinating configuration across multiple services
With Monk: Provide credentials once. Monk provisions API resources, manages secrets, updates configurations automatically, and maintains a complete system map.

​
Key Capabilities

  • Lifecycle orchestration - Provision, configure, update, and manage API resources
  • Automatic detection - Identifies API dependencies from code
  • Dynamic configuration - Updates webhook URLs, callbacks as deployments change
  • Secret management - Obtains and injects API keys securely
  • Unified system map - Complete view of all resources, including third-party APIs
  • Multi-API support - Stripe + Auth0 + SendGrid + more in one deployment
  • Credential injection - API keys available to services that need them
  • BYOI model - Works with your accounts on third-party platforms
  • Secure storage - API credentials stored securely on your infrastructure

​
Coming Soon

Several API orchestration features are actively in development: Expanded API Support COMING SOON
  • SendGrid (email sending)
  • Twilio (SMS/voice)
  • Mailgun (email)
  • More authentication providers (Okta, Firebase Auth)
  • Additional payment providers
Advanced Orchestration COMING SOON
  • Automatic API resource cleanup on teardown
  • Multi-environment API resource management
  • API usage monitoring and alerts