LangChain Integration

pip install payments-py[langchain] langgraph langchain-openai

from payments_py.x402.langchain import (
    requires_payment,
    PaymentRequiredError,
    last_settlement,
    create_paid_react_agent,
)

def requires_payment(
    payments: Payments,
    plan_id: str | None = None,
    plan_ids: list[str] | None = None,
    credits: int | Callable[[dict], int] = 1,
    agent_id: str | None = None,
    network: str | None = None,
    scheme: str | None = None,
) -> Callable

from langchain_core.runnables import RunnableConfig
from langchain_core.tools import tool
from payments_py import Payments, PaymentOptions
from payments_py.x402.langchain import requires_payment

payments = Payments.get_instance(
    PaymentOptions(nvm_api_key="nvm:builder-key", environment="sandbox")
)

@tool
@requires_payment(payments=payments, plan_id="plan-123", credits=1)
def get_market_insight(topic: str, config: RunnableConfig = None) -> str:
    """Return a short market insight. Costs 1 credit per call."""
    return f"Market insight for '{topic}': demand is up 12% QoQ."

from payments_py.x402.langchain import PaymentRequiredError

try:
    agent.invoke({"messages": [("human", "...")]}, config={"configurable": {}})
except PaymentRequiredError as err:
    accepts = err.payment_required.accepts[0]
    # accepts.scheme    → "nvm:erc4337" or "nvm:card-delegation"
    # accepts.network   → CAIP-2 chain or provider name (stripe, braintree, visa)
    # accepts.plan_id   → which plan to acquire a token against

def last_settlement() -> SettleResponse | None

from payments_py.x402.langchain import last_settlement

result = agent.invoke(
    {"messages": [("human", "...")]},
    config={"configurable": {"payment_token": token}},
)

receipt = last_settlement()
if receipt:
    print(f"  credits_redeemed: {receipt.credits_redeemed}")
    print(f"  remaining_balance: {receipt.remaining_balance}")
    print(f"  transaction: {receipt.transaction}")

def create_paid_react_agent(
    model: Any,
    tools: Sequence[Any],
    **kwargs: Any,
) -> CompiledStateGraph

from langchain_openai import ChatOpenAI
from payments_py.x402.langchain import create_paid_react_agent, requires_payment

@tool
@requires_payment(payments=payments, plan_id=PLAN_ID, credits=1)
def get_market_insight(topic: str, config=None) -> str:
    return f"Market insight for {topic} ..."

agent = create_paid_react_agent(
    ChatOpenAI(model="gpt-4o-mini", temperature=0),
    [get_market_insight],
    prompt="You are a market data assistant. Always call get_market_insight.",
)

import os
from dotenv import load_dotenv
from payments_py import Payments, PaymentOptions
from payments_py.x402.langchain import (
    PaymentRequiredError,
    create_paid_react_agent,
    last_settlement,
    requires_payment,
)
from payments_py.x402.types import (
    CreateDelegationPayload,
    DelegationConfig,
    X402TokenOptions,
)

load_dotenv()
payments = Payments.get_instance(
    PaymentOptions(
        nvm_api_key=os.environ["NVM_API_KEY"],
        environment=os.getenv("NVM_ENVIRONMENT", "sandbox"),
    )
)

# 1. Build the agent (see the LangChain integration guide for the protected tool).
agent = create_paid_react_agent(model, [get_market_insight], prompt=prompt)

# 2. Discover what the agent's tool charges by invoking without a token.
try:
    agent.invoke({"messages": [("human", QUERY)]}, config={"configurable": {}})
except PaymentRequiredError as err:
    accept = err.payment_required.accepts[0]

# 3. Create a delegation once (currency is required), then acquire a token
#    against the discovered plan by referencing the delegation id.
pm = next(m for m in payments.delegation.list_payment_methods()
          if m.provider == accept.network)
delegation = payments.delegation.create_delegation(
    CreateDelegationPayload(
        provider=pm.provider,
        provider_payment_method_id=pm.id,
        spending_limit_cents=10000,
        duration_secs=3600,
        currency="usd",
    )
)
token = payments.x402.get_x402_access_token(
    accept.plan_id,
    token_options=X402TokenOptions(
        scheme=accept.scheme,
        delegation_config=DelegationConfig(delegation_id=delegation.delegation_id),
    ),
)["accessToken"]

# 4. Retry with the token and read the settlement.
result = agent.invoke(
    {"messages": [("human", QUERY)]},
    config={"configurable": {"payment_token": token}},
)
receipt = last_settlement()

pip install "payments-py[langchain,langsmith]"

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY=<your-langsmith-api-key>
export LANGSMITH_PROJECT=<your-project-name>  # optional

export LANGSMITH_ENDPOINT=https://eu.api.smith.langchain.com

from payments_py.langsmith import (
    settlement_span,
    verify_span,
    build_settle_metadata,
)

with settlement_span(plan_ids=["plan-1"]) as span:
    settlement = payments.facilitator.settle_permissions(...)
    if span is not None:
        span.add_metadata(build_settle_metadata(settlement, ["plan-1"]))

main agent  --task()-->  research-sub  -->  market_research  [PAID]
     ^                                             |
     +--------- x402 token supplied here ----------+
               config.configurable.payment_token

from deepagents import create_deep_agent
from langchain_core.runnables import RunnableConfig
from langchain_core.tools import tool

from payments_py.x402.langchain import PaymentRequiredError, requires_payment


@requires_payment(payments=payments, plan_id=PLAN_ID, credits=5)
def _market_research_paid(topic: str, config: RunnableConfig) -> str:
    return run_analyst(topic)


@tool
def market_research(topic: str, config: RunnableConfig) -> str:
    """Paid market research on a topic."""
    try:
        # `config` must be forwarded explicitly — the decorator reads the
        # token from it.
        return _market_research_paid(topic, config=config)
    except PaymentRequiredError:
        return "PAYMENT_REQUIRED: authorize and ask again."


# The paid tool is given ONLY to the subagent, so every paid call crosses
# a delegation boundary.
graph = create_deep_agent(
    model="openai:gpt-4o-mini",
    tools=[],
    subagents=[{
        "name": "research-sub",
        "description": "Performs paid market research.",
        "system_prompt": "Call market_research once and return its output verbatim.",
        "tools": [market_research],
    }],
    system_prompt="Delegate research requests to research-sub.",
)

graph.invoke(
    {"messages": [{"role": "user", "content": "Research the EV market"}]},
    config={"configurable": {"payment_token": access_token}},
)

python3.11 -m venv .venv-deepagents
.venv-deepagents/bin/pip install -e ".[langchain,langsmith]"
.venv-deepagents/bin/pip install deepagents pytest
.venv-deepagents/bin/pytest tests/unit/x402/test_deepagents_compat.py