How to Integrate LangChain for payments with Slack for AI agents

Combining LangChain for payments with Slack gives you a clean way to let AI agents trigger payment-related workflows from the place your operators already live. The practical win is simple: a support or finance team can approve, reject, or inspect payment actions in Slack while the agent handles routing, validation, and execution behind the scenes.

Prerequisites

• •Python 3.10+
• •A Slack workspace with:
  • •A Slack app created
  • •Bot token with chat:write, channels:read, groups:read, im:read, mpim:read
  • •Signing secret if you plan to receive interactive events
• •LangChain installed and configured for your agent runtime
• •Access to your payments provider or payment tool wrapped in LangChain
• •Environment variables set:
  • •SLACK_BOT_TOKEN
  • •SLACK_APP_TOKEN if using Socket Mode
  • •PAYMENTS_API_KEY or provider-specific credentials
• •A Python webhook server framework such as FastAPI or Flask

Integration Steps

1. •

   Install the required packages

   You need Slack’s SDK for messaging and LangChain for the agent orchestration layer.

   pip install langchain langchain-openai slack-sdk fastapi uvicorn python-dotenv
   

2. •

   Initialize the Slack client and your payment tool

   In production, keep Slack transport separate from payment execution. The agent should decide, but the payment tool should own the actual API call.

   import os
   from slack_sdk import WebClient
   
   # Example payment tool wrapper used by LangChain-style agents
   class PaymentTool:
       name = "create_payment"
   
       def __init__(self):
           self.api_key = os.environ["PAYMENTS_API_KEY"]
   
       def run(self, amount_cents: int, currency: str, recipient_id: str) -> dict:
           # Replace with your real payments SDK/API call
           return {
               "status": "success",
               "payment_id": "pay_12345",
               "amount_cents": amount_cents,
               "currency": currency,
               "recipient_id": recipient_id,
           }
   
   slack_client = WebClient(token=os.environ["SLACK_BOT_TOKEN"])
   payment_tool = PaymentTool()
   

3. •

   Build a LangChain agent that can call the payment tool

   Use initialize_agent() with a tool wrapper so the model can decide when to execute a payment action. If you’re using modern LangChain patterns, you can also wire this into a tool-calling agent.

   from langchain.agents import initialize_agent, AgentType
   from langchain_core.tools import Tool
   from langchain_openai import ChatOpenAI
   
   def create_payment(amount_cents: int, currency: str, recipient_id: str) -> str:
       result = payment_tool.run(
           amount_cents=amount_cents,
           currency=currency,
           recipient_id=recipient_id,
       )
       return str(result)
   
   tools = [
       Tool(
           name="create_payment",
           func=lambda x: create_payment(**x),
           description="Create a payment after approval"
       )
   ]
   
   llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
   agent = initialize_agent(
       tools=tools,
       llm=llm,
       agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
       verbose=True,
   )
   

4. •

   Send Slack notifications when the agent needs approval

   This is the key pattern for human-in-the-loop payments. The agent prepares a request, then posts a structured message to Slack for review.

   import json
   
   def notify_slack_for_approval(channel_id: str, payload: dict) -> dict:
       text = (
           f"Payment approval needed:\n"
           f"- Amount: {payload['amount_cents']} {payload['currency']}\n"
           f"- Recipient: {payload['recipient_id']}\n"
           f"- Request ID: {payload['request_id']}"
       )
   
       response = slack_client.chat_postMessage(
           channel=channel_id,
           text=text,
           blocks=[
               {
                   "type": "section",
                   "text": {"type": "mrkdwn", "text": text},
               },
               {
                   "type": "actions",
                   "elements": [
                       {
                           "type": "button",
                           "text": {"type": "plain_text", "text": "Approve"},
                           "style": "primary",
                           "action_id": f"approve_{payload['request_id']}",
                       },
                       {
                           "type": "button",
                           "text": {"type": "plain_text", "text": "Reject"},
                           "style": "danger",
                           "action_id": f"reject_{payload['request_id']}",
                       },
                   ],
               },
           ],
       )
       return response.data
   

5. •

   Wire approval handling back into the agent flow

   When someone clicks Approve in Slack, your webhook handler should validate the event and then execute the payment through the tool.

   from fastapi import FastAPI, Request
   
   app = FastAPI()
   
   @app.post("/slack/interactions")
   async def slack_interactions(request: Request):
       form = await request.form()
       payload = json.loads(form["payload"])
   
       action_id = payload["actions"][0]["action_id"]
       user_id = payload["user"]["id"]
   
       if action_id.startswith("approve_"):
           request_id = action_id.replace("approve_", "")
           # Lookup pending request by request_id in your DB/cache
           pending_payment = {
               "amount_cents": 2500,
               "currency": "USD",
               "recipient_id": "acct_987",
           }
   
           result = payment_tool.run(**pending_payment)
   
           slack_client.chat_postMessage(
               channel=payload["channel"]["id"],
               text=f"Approved by <@{user_id}>. Payment executed: {result['payment_id']}"
           )
           return {"ok": True}
   
       if action_id.startswith("reject_"):
           slack_client.chat_postMessage(
               channel=payload["channel"]["id"],
               text=f"Payment rejected by <@{user_id}>."
           )
           return {"ok": True}
   
       return {"ok": False}
   

Testing the Integration

Run your FastAPI app and simulate an approval workflow end to end.

test_payload = {
    "request_id": "req_001",
    "amount_cents": 5000,
    "currency": "USD",
    "recipient_id": "acct_demo_01",
}

notify_slack_for_approval("#payments-ops", test_payload)

# Simulate what happens after approval in your handler:
result = payment_tool.run(5000, "USD", "acct_demo_01")
print(result)

Expected output:

{
  'status': 'success',
  'payment_id': 'pay_12345',
  'amount_cents': 5000,
  'currency': 'USD',
  'recipient_id': 'acct_demo_01'
}

If Slack is wired correctly, you should also see an approval message posted to #payments-ops.

Real-World Use Cases

• •Payment approvals in ops channels
  • •Route high-value transactions to Slack for human approval before execution.
• •Dispute handling assistants
  • •Let an AI agent gather context, draft responses, and notify finance/support teams in Slack.
• •Treasury workflow automation
  • •Have agents monitor thresholds and post alerts when payout batches exceed policy limits.

Keep learning

• •The complete AI Agents Roadmap — my full 8-step breakdown
• •Free: The AI Agent Starter Kit — PDF checklist + starter code
• •Work with me — I build AI for banks and insurance companies

By Cyprian Aarons, AI Consultant at Topiax.