How to Integrate OpenAI for fintech with AWS Lambda for AI agents

OpenAI for fintech plus AWS Lambda is a practical combo when you need agentic workflows that react to financial events without running a full server. You get the model reasoning layer from OpenAI, and Lambda gives you event-driven execution for things like transaction triage, KYC review, fraud escalation, and customer support routing.

Prerequisites

• •Python 3.10+
• •An AWS account with:
  • •IAM permissions to create Lambda functions
  • •CloudWatch Logs access
• •AWS CLI configured locally:
  • •aws configure
• •An OpenAI API key stored as an environment variable:
  • •export OPENAI_API_KEY="your-key"
• •boto3 installed:
  • •pip install boto3
• •openai Python SDK installed:
  • •pip install openai
• •A basic understanding of:
  • •AWS Lambda handlers
  • •JSON event payloads
  • •Environment variables in Lambda

Integration Steps

1. •

   Create a Lambda handler that receives the fintech event

   Your agent system usually starts with an event: a card transaction, account change, or support ticket. Lambda should accept that payload, normalize it, and pass only the fields the model needs.

   import json
   import os
   from openai import OpenAI
   
   client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
   
   def lambda_handler(event, context):
       transaction = {
           "transaction_id": event["transaction_id"],
           "amount": event["amount"],
           "currency": event["currency"],
           "merchant": event["merchant"],
           "country": event["country"],
           "user_risk_score": event.get("user_risk_score", 0)
       }
   
       return {
           "statusCode": 200,
           "body": json.dumps(transaction)
       }
   

2. •

   Call OpenAI from Lambda to classify the financial event

   Use the Responses API to turn raw transaction data into an agent decision. For fintech, keep outputs structured so downstream systems can automate on them.

   import json
   import os
   from openai import OpenAI
   
   client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
   
   def lambda_handler(event, context):
       prompt = f"""
       You are a fintech risk analyst.
       Classify this transaction as LOW_RISK, MEDIUM_RISK, or HIGH_RISK.
       Return JSON only with keys: risk_level, reason, action.
   
       Transaction:
       {json.dumps(event)}
       """
   
       response = client.responses.create(
           model="gpt-4.1-mini",
           input=prompt
       )
   
       result_text = response.output_text
       return {
           "statusCode": 200,
           "body": result_text
       }
   

3. •

   Use structured output so your agent can route decisions reliably

   In production, do not parse free-form text if you can avoid it. Ask the model for strict JSON and validate it before triggering any workflow.

   import json
   import os
   from openai import OpenAI
   
   client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
   
   def lambda_handler(event, context):
       response = client.responses.create(
           model="gpt-4.1-mini",
           input=[
               {
                   "role": "system",
                   "content": "You are a fintech compliance assistant. Output valid JSON only."
               },
               {
                   "role": "user",
                   "content": json.dumps({
                       "transaction_id": event["transaction_id"],
                       "amount": event["amount"],
                       "currency": event["currency"],
                       "merchant": event["merchant"],
                       "country": event["country"]
                   })
               }
           ]
       )
   
       output = json.loads(response.output_text)
   
       return {
           "statusCode": 200,
           "body": json.dumps(output)
       }
   

4. •

   Trigger downstream AWS actions from the Lambda decision

   Once the model returns a risk label, use AWS SDK calls to publish alerts, write audit logs, or trigger Step Functions. This is where the agent becomes operational instead of just conversational.

   import json
   import os
   import boto3
   from openai import OpenAI
   
   client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
   sns = boto3.client("sns")
   
   ALERT_TOPIC_ARN = os.environ["ALERT_TOPIC_ARN"]
   
   def lambda_handler(event, context):
       prompt = f"""
       Classify this fintech transaction.
       Return JSON with risk_level and action.
       
       {json.dumps(event)}
       """
   
       response = client.responses.create(
           model="gpt-4.1-mini",
           input=prompt
       )
   
       decision = json.loads(response.output_text)
   
       if decision["risk_level"] == "HIGH_RISK":
           sns.publish(
               TopicArn=ALERT_TOPIC_ARN,
               Subject="High-risk transaction detected",
               Message=json.dumps({
                   "transaction_id": event["transaction_id"],
                   "decision": decision
               })
           )
   
       return {
           "statusCode": 200,
           "body": json.dumps(decision)
       }
   

5. •

   Package and deploy the Lambda function

   Keep dependencies small. For simple agent handlers, bundle your code with openai and boto3, then deploy using ZIP or a container image.

   mkdir package && cd package
   pip install openai boto3 -t .
   cp ../lambda_function.py .
   zip -r function.zip .
   
   aws lambda create-function \
     --function-name fintech-agent-handler \
     --runtime python3.10 \
     --handler lambda_function.lambda_handler \
     --zip-file fileb://function.zip \
     --role arn:aws:iam::123456789012:role/lambda-fintech-role \
     --environment Variables="{OPENAI_API_KEY=$OPENAI_API_KEY,ALERT_TOPIC_ARN=arn:aws:sns:us-east-1:123456789012:fintech-alerts}"
   

Testing the Integration

Invoke the Lambda locally or through AWS with a sample transaction payload.

import json

test_event = {
    "transaction_id": "tx_10001",
    "amount": 9500,
    "currency": "USD",
    "merchant": "Crypto Exchange Ltd",
    "country": "NG"
}

print(lambda_handler(test_event, None))

Expected output:

{
  "statusCode": 200,
  "body": "{\"risk_level\": \"HIGH_RISK\", \"action\": \"flag_for_manual_review\"}"
}

If SNS is wired correctly, you should also see a CloudWatch log entry for the publish call and an alert in the target topic subscription.

Real-World Use Cases

• •

  Fraud triage agents

  • •Score incoming transactions with OpenAI and route high-risk cases to SNS or Step Functions for manual review.
• •

  KYC document assistants

  • •Use Lambda to receive uploaded documents from S3 events, extract metadata, and ask OpenAI to classify missing fields or suspicious patterns.
• •

  Customer support routing

  • •Let an agent summarize dispute tickets and decide whether to escalate to chargeback operations, card servicing, or compliance.

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.