Conto Hybrid Integration

# Conto Hybrid Integration

> Use Conto as the spend-management control center while your app keeps execution and settlement.

- Human URL: https://conto.finance/docs/guides/conto-hybrid-integration
- Raw Markdown: https://conto.finance/docs/guides/conto-hybrid-integration.md
- Terminal view: https://conto.finance/ai/docs/guides/conto-hybrid-integration

Documentation group: Guides

# Conto Hybrid Integration

Use this pattern when your app already owns the runtime, wallet flow, or provider settlement path and you want Conto to enforce policy before money moves.

In a hybrid integration:

- your app decides when a paid action is about to happen
- Conto approves, denies, or routes that payment to review
- your app executes the actual settlement
- your app records the final spend back to Conto

## What hybrid means

In managed execution, Conto both authorizes and executes payment through a managed wallet.

In hybrid execution, Conto stays in the control center while your app stays in the execution path.

That makes hybrid a strong fit when you already have:

- an existing wallet or treasury layer
- custom routing or fallback logic
- provider-specific settlement code
- x402 or MPP payment handling in your own runtime

The main rule is simple:

Conto should make the authorization decision before your app executes the payment.

If your app settles first and reports later, Conto becomes an analytics mirror instead of a real spend-control layer.

## When to use hybrid

Choose hybrid when:

- you want to keep your current runtime architecture
- paid actions are embedded inside a larger workflow
- you need policy checks before API calls, machine payments, or provider settlements
- you want Conto controls without moving all execution into Conto-managed wallets

Hybrid is especially useful for agent platforms, AI orchestration products, marketplaces, and machine-payment systems.

## Responsibility split

### Your app owns

- the user experience
- workflow and routing logic
- provider selection and fallback behavior
- execution timing
- the settlement call itself
- app-specific state and reporting

### Conto owns

- spend policies
- approval thresholds
- allowlists and counterparties
- budget controls
- runtime authorization
- audit visibility
- spend analytics

## Canonical flow

```mermaid
flowchart LR
    App["Your app"] --> Context["Build payment context"]
    Context --> Authorize["Conto authorization"]
    Authorize --> Gate{"Decision"}
    Gate -->|"Approved"| Execute["Your app executes payment"]
    Gate -->|"Requires review"| Review["Approval workflow"]
    Gate -->|"Denied"| Stop["Do not settle"]
    Review -->|"Approved"| Execute
    Review -->|"Rejected"| Stop
    Execute --> Record["Record final spend back to Conto"]
    Record --> Audit["Audit logs, analytics, budgets"]
```

## Recommended integration steps

1. Keep the product-facing controls in your app.
2. Provision a Conto agent for each managed actor.
3. Create and protect a runtime credential for that actor.
4. Sync supported controls into Conto policy objects.
5. Call Conto before the paid action executes.
6. Execute the payment in your own runtime only if approved.
7. Record the settled spend back to Conto.

## Common policy mappings

| Product control              | Conto primitive                       |
| ---------------------------- | ------------------------------------- |
| Max spend per action         | `SPEND_LIMIT`                         |
| Budget per session or run    | `BUDGET_ALLOCATION`                   |
| Allowed providers or vendors | `COUNTERPARTY` or `WHITELIST`         |
| Human review threshold       | `APPROVAL_THRESHOLD`                  |
| Time-based restrictions      | Time or blackout-related policy types |

## Verification checklist

Use this checklist after setup:

- each managed actor gets a dedicated Conto binding
- runtime credentials stay server-side and encrypted at rest
- policy changes update Conto objects
- pre-authorization happens before settlement
- denied payments never reach the execution layer
- successful payments are recorded back to Conto
- operators can see runtime status and recent events

## Related guides

### Choose Your Integration
Link: https://conto.finance/guides/choose-your-integration

    Compare SDK, OpenClaw, Hermes, x402, and MPP paths

### Architecture Patterns
Link: https://conto.finance/guides/architecture-patterns

    See the core managed, external wallet, x402, and MPP diagrams

### x402 API Payments
Link: https://conto.finance/guides/x402-api-payments

    Govern pay-per-call API payments before execution

### MPP Session Payments
Link: https://conto.finance/guides/mpp-session-payments

    Control repeated charges inside a session budget