Build an Automated AI Sales Offer System with CrewAI and n8n

Tired of sending the same sales pitches to all of your customers? Want to increase your conversion rates and revenue without spending hours crafting personalized offers?

Today we’ll be building a multi-agent AI sales system that sends personalized sales offers to customers automatically. The system works while you sleep, increasing conversion and revenue through tailored messaging.

This CrewAI n8n tutorial will show you how to build an automated sales system that can analyze customer data, create detailed profiles, generate custom offers, and deliver them directly to customers – all without human intervention.

We’ll be using the CrewAI framework combined with an n8n workflow to create this powerful AI sales automation system. Our approach uses multiple specialized AI agents working together to create truly personalized sales experiences.

The system consists of:

• Four specialized AI agents:
  • Customer Data Analyst
  • Customer Profiling Specialist
  • Sales Offer Strategist
  • Technical Offer Formatter

• Four key tasks:
  • Fetch customer data
  • Create customer profiles
  • Generate personalized offers
  • Format offers for delivery

• Two essential tools:
  • Brave Search Tool (for real-time information gathering)
  • Custom Airtable Tool (for accessing customer data)

This tutorial is perfect for developers, tech entrepreneurs, and business owners looking to leverage AI for personalized sales outreach. The finished system will be fully automated, allowing you to scale your sales efforts without increasing your workload.

Welcome to the future of sales – let’s get started!

Deep Dive into CrewAI

CrewAI is a powerful framework for building multi-agent AI systems. Unlike single-agent approaches, CrewAI lets you create specialized AI agents that work together, each with specific roles, goals, and backstories.

In our AI sales agent tutorial, we’ll be using CrewAI to create a team of four specialized agents:

1. Customer Data Analyst: This agent extracts and analyzes customer data from our Airtable database. It identifies patterns and key information that will be useful for creating personalized offers.
2. Customer Profiling Specialist: Taking the raw data from the analyst, this agent creates comprehensive customer profiles. It considers demographics, purchase history, browsing behavior, and preferences to build a complete picture of each customer.
3. Sales Offer Strategist: Using the customer profiles, this agent develops personalized sales offers. It determines the most appealing products, appropriate discount levels, and compelling messaging for each customer.
4. Technical Offer Formatter: This agent takes the personalized offers and formats them for delivery. It structures the data in a way that can be easily processed by our automation workflow.

Each agent in the CrewAI framework has three key components:

• Role: What the agent does (e.g., “Customer Data Analyst”)
• Goal: What the agent is trying to achieve (e.g., “Extract valuable customer insights from raw data”)
• Backstory: Context that guides the agent’s behavior (e.g., “You are an experienced data analyst with expertise in identifying customer patterns”)

These components help the agents understand their responsibilities and how they should interact with each other.

The agents work through a series of tasks:

• Fetch Customer Data Task: Retrieves customer information from our Airtable database
• Create Customer Profiles Task: Analyzes the data to build detailed customer profiles
• Generate Personalized Offers Task: Creates tailored offers based on customer profiles
• Format Offers Task: Structures the offers for delivery via email

To accomplish these tasks, our agents need access to tools. In this CrewAI tutorial, we’ll implement:

1. Brave Search Tool: This allows our agents to search the web for up-to-date information that might be relevant to creating personalized offers. For example, the Sales Offer Strategist might look up current trends related to a customer’s interests.
2. Custom Airtable Tool: We’ll create a custom tool that allows our agents to fetch customer data stored in Airtable. This gives the system access to customer information like names, email addresses, age, gender, location, and preferences.

Leveraging n8n for Automation

While CrewAI handles the intelligence behind our system, we need a way to trigger the process and deliver the results. That’s where n8n comes in.

n8n is a workflow automation platform that lets you connect different applications and services without writing code. In our case, we’ll use n8n to:

1. Trigger our CrewAI system to generate personalized offers
2. Check when the process is complete
3. Process the results
4. Send personalized emails to customers

When we deploy our CrewAI system (which we’ll do later using CrewAI Enterprise), it creates API endpoints that n8n can interact with. These endpoints allow n8n to:

• Start the CrewAI process
• Check the status of the process
• Retrieve the results once the process is complete

This integration creates a fully automated pipeline: n8n triggers CrewAI, CrewAI generates personalized offers, and then n8n delivers those offers to customers via email.

Setting Up the CrewAI Environment

Before we build our AI sales system, we need to set up our CrewAI environment. The process is straightforward but requires attention to a few important details.

First, CrewAI has specific Python version requirements. You need Python version between 3.10 and above and below 3.13. This is crucial – if you’re using Python 3.13 or higher (like I was initially), you’ll need to downgrade.

To check your Python version, run this command in your terminal:

Next, we need to install UV, a package manager for Python:

For MacOS users:

For Windows users:

Once UV is installed, we can install the CrewAI CLI:

With the CLI installed, we can create a new CrewAI project:

This command creates a new folder with the basic structure for our CrewAI project. The CLI will ask a few questions to configure your project:

• Which LLM provider you want to use (we’ll select OpenAI)
• Which model to use (we’ll select GPT-4o mini, though you can change this later)
• Your API key (you can hit enter for now and add it later)

After the project is created, you’ll have a folder structure that includes:

• A source directory
• A config folder with agent and task definitions
• A tools folder for custom tools
• A crew.py file for constructing your crew
• A main.py file with the run function that starts your system

This structure gives us a solid foundation to build our AI sales system.

Defining Agents, Tasks, and Tools for Personalized Sales

Now that we have our basic project structure, we need to define our agents, tasks, and tools. For this tutorial, I’ll be using Claude 3.7 Sonnet with agent mode prompted to help us create the code. This AI assistant will help us generate the boilerplate code we need.

Let’s start by defining our data model. We’ll create a Pydantic model to structure the sales offers our system will generate:

This model captures all the information we need for a personalized sales offer: customer details, offer specifics, recommended products, and personalization elements.

Next, let’s define our four agents in the agents.yaml file:

Each agent has a clear role, goal, and backstory.

Now, let’s define the tasks for our agents in the tasks.yaml file:

Each task has a clear description, an assigned agent, and an expected output.

Connecting to Customer Data: The Airtable Integration

For our AI sales system to work, it needs access to customer data. We’ll use Airtable as our database because it’s easy to set up and integrate.

First, create an Airtable base with a table named “Customers” that includes these fields:

• ID (text)
• Customer Name (text)
• Email (text)
• Age (number)
• Gender (single select)
• Location (text)
• Purchase History (text)
• Preferred Category (single select)
• Recently Viewed Items (multiple select)

Add some sample customer data to test the system. Include a variety of demographics, interests, and behaviors to see how the system creates different personalized offers.

Next, we need to create a custom Airtable tool for our CrewAI agents. Here’s the code for our airtable_tool.py:

This tool connects to our Airtable database using the API key, base ID, and table name we’ll specify in our environment variables.

We need to create a .env file to store these variables:

You’ll need to get these API keys from:

• OpenAI: platform.openai.com
• Airtable: airtable.com/developers/api
• Brave Search: brave.com/search/api

For the Airtable Base ID, look at the URL of your Airtable base. It’s the part that starts with “app” after “airtable.com/” – copy that and paste it in your .env file.

Building the Crew and Run Function

Lastly, let’s update our crew.py and main.py files:

Deployment (Using CrewAI Enterprise as an Example)

Now let’s deploy our CrewAI system so n8n can interact with it. We’ll use CrewAI Enterprise for this, as it provides a simple way to deploy our system and create API endpoints.

First, make sure your code is in a GitHub repository. CrewAI Enterprise can connect directly to GitHub to deploy your code.

1. Create a new repository on GitHub
2. Push your code to the repository
3. Log in to CrewAI Enterprise
4. Create a new project
5. Connect to your GitHub repository
6. Configure your deployment settings
   • Select the repository
   • Select the branch (usually main)
   • Enable automatic deployment for new commits
7. Add your environment variables
   • OPENAI_API_KEY
   • AIRTABLE_BASE_ID
   • AIRTABLE_TABLE_NAME
   • AIRTABLE_API_KEY
   • BRAVE_API_KEY
8. Deploy your project

CrewAI Enterprise will automatically deploy your code and create API endpoints for you. It typically takes about 10 minutes for the deployment to complete.

Once the deployment is complete, you’ll have three endpoints:

1. /inputs – Get information about the inputs your crew expects
2. /kickoff – Start the CrewAI process
3. /status/{kickoff_id} – Check the status of a running process

You can test these endpoints directly in the CrewAI Enterprise interface before connecting them to n8n.

To test the /kickoff endpoint, send a POST request with an empty JSON object {}. This will return a kickoff ID.

To test the /status endpoint, send a GET request with the kickoff ID in the URL. This will return the status of the process and the result if it’s complete.

Once you’ve verified that everything is working, you can update your n8n workflow with the actual endpoint URLs provided by CrewAI Enterprise.

Automating the Workflow with n8n

Now that we have our CrewAI system set up, we need to create an n8n workflow to automate the process and deliver our personalized offers to customers via email. In this section, I’ll walk you through building a complete n8n workflow step by step.

With our backend ready, let’s build the n8n workflow. You can access n8n by either:

• Self-hosting it on your own server
• Using n8n.io, their hosted service (offers a free trial)

Step 1: Setting Up the Initial HTTP Request

Start with an HTTP Request node to trigger our CrewAI system:

1. Create a new workflow in n8n
2. Add an HTTP Request node
3. Configure it:
   • Method: POST
   • URL: Your CrewAI Enterprise kickoff endpoint
   • Authentication: Bearer Token (paste your CrewAI Enterprise API key)
   • Request Body: {"inputs": {}}
   • Content Type: application/json
4. Name this node “Kickoff Crew”
5. Test it by clicking “Test step”

If successful, you’ll get a response like:

This kickoff ID is what we’ll use to check the status of our CrewAI process.

Step 2: Creating a Status-Checking Loop

Next, we need to check if our CrewAI process has completed. Since this can take 30-60 seconds, we’ll create a loop:

1. Add another HTTP Request node
2. Configure it:
   • Method: GET
   • URL: Your CrewAI Enterprise status endpoint + the kickoff ID from the previous step (For example: https://sales-offer-crew-123.crewai.com/status/{{ $('Kickoff Crew').item.json.kickoff_id }})
   • Authentication: Bearer Token (same as before)
3. Name this node “Get Status”
4. Connect it to the “Kickoff Crew” node

Now we need to create a conditional loop that checks if the process is complete:

1. Add an IF node
2. Connect it to the “Get Status” node
3. Configure the condition:
   • Value 1: {{$json.state}}
   • Operation: is equal to
   • Value 2: SUCCESS
4. Name this node “Check If Complete”

This node has two paths:

• The “true” path (when status = “SUCCESS”)
• The “false” path (when status = “RUNNING” or “FAILED”)

Let’s handle the “false” path first:

1. Add a Wait node
2. Connect it to the “false” output of the “Check If Complete” node
3. Configure it to wait for 15 seconds
4. Name this node “Wait 15 Seconds”
5. Connect this node back to the “Get Status” node to create a loop

This creates a polling loop that checks the status every 15 seconds until it succeeds.

Step 3: Processing the Results

Once the status is “SUCCESS”, we need to extract and process the offers:

1. Add a Set node
2. Connect it to the “true” output of the “Check If Complete” node
3. Configure it to extract the offers array:
   • Name: offers
   • Data type: Array
   • Value: {{ $('Get Status').item.json.result.parseJson().offers }}
4. Name this node “Extract Offers”

Now we need to split the offers array so we can send an email for each offer:

1. Add a Split In Batches node
2. Connect it to the “Extract Offers” node
3. Configure it:
   • Input Field: offers
   • Batch Size: 1
4. Name this node “Split Offers”

This will output each offer individually, allowing us to send personalized emails to each customer.

Step 4: Sending Personalized Emails

Finally, we’ll send personalized emails to each customer:

1. Add an Email node
2. Connect it to the “Split Offers” node
3. Configure your SMTP settings (server, port, username, password)
4. Configure the email content:
   • From: Your email address
   • To: {{ $json.customer_email}}
   • Subject: {{ $json.offer_title }}
   • Content Type: HTML
   • HTML: Generate a template (see example template below)
5. Name this node “Send Personalized Email”

Here’s an HTML email template you can use:

Step 5: Testing the Workflow

Now that our workflow is complete, it’s time to test it:

1. Click “Test workflow” at the bottom of the n8n interface
2. Watch the execution progress through each node
3. The workflow will:
   • Kick off the CrewAI process
   • Check the status repeatedly until it’s complete
   • Extract the offers
   • Split them into individual items
   • Send personalized emails to each customer

The first time you run this workflow, it might take several minutes for the CrewAI process to complete. Be patient and watch the execution progress.

Step 6: Automating the Workflow

To make this system truly automated, you can add a trigger node at the beginning of your workflow:

1. Add a Schedule Trigger node at the start of your workflow
2. Configure it to run on your desired schedule (e.g., once a week)
3. Connect it to the “Kickoff Crew” node

Now your workflow will run automatically according to your schedule, generating and sending personalized offers without any manual intervention.

Let’s check one of the emails the system sent in our test. For example, here’s the email Isabella Kim received:

Notice how the system recommended beauty products specifically for Isabella, based on her preferences and browsing history from the Airtable data. The system recognized that her preferred category is beauty and that she recently viewed Korean skin care and hair products, so it tailored the recommendations accordingly.

This is the power of our AI sales system – each customer receives highly personalized offers based on their unique profile, all generated and delivered automatically.

Building an AI-powered sales automation system with CrewAI and n8n offers several key benefits:

1. Personalization at Scale: The system can analyze customer data and create highly personalized sales offers for each customer. This level of personalization would be impossible to achieve manually for a large customer base.
2. 24/7 Operation: Once set up, the system works continuously, generating and sending offers even when you’re not actively working.
3. Improved Conversion Rates: Personalized offers are more likely to resonate with customers, leading to higher conversion rates and increased revenue.
4. Reduced Workload: Automating the sales offer process frees up your time to focus on other aspects of your business.
5. Scalability: As your customer base grows, the system can easily scale to handle more customers without requiring additional manual work.
6. Data-Driven Insights: The Customer Data Analyst agent can identify patterns and trends in your customer data, providing valuable insights for your marketing strategy.
7. Real-Time Information: The Brave Search tool allows the system to incorporate current trends and information into the offers, making them more relevant and timely.
8. Professional Presentation: The HTML email template ensures that the offers are presented in a professional and visually appealing way.

If you want to build your own AI-powered sales automation system, here’s a checklist to get started:

1. Set Up Your Environment:
   • Install Python (version between 3.10 and 3.13)
   • Install the UV package manager
   • Install the CrewAI CLI
   • Create a new CrewAI project
2. Gather Your API Keys:
   • OpenAI API key
   • Airtable API key
   • Brave Search API key
3. Set Up or Connect Your Customer and Product Database:
   • Use your existing database or create an Airtable base with customer and product data
   • Note your Airtable Base IDs and table names
4. Implement the Code:
   • Define your agents with roles, goals, and backstories
   • Create tasks for each step of the process
   • Implement custom tools to fetch customer and product data (e.g., Airtable tool)
   • Set up the crew to orchestrate the agents and tasks
5. Deploy Your System:
   • Push your code to GitHub
   • Deploy using CrewAI Enterprise
   • Note the API endpoints
6. Create Your n8n Workflow:
   • Set up the HTTP Request nodes to interact with your CrewAI system
   • Implement the looping logic to check when the process completes
   • Create the email template for delivering offers
   • Configure the email sending settings
7. Test and Refine:
   • Start with a small batch of customers
   • Review the offers generated by the system
   • Adjust the agent prompts and tasks as needed
   • Monitor conversion rates and make further refinements

The AI sales system we’ve built in this tutorial represents the future of sales automation – intelligent, personalized, and always working. By combining the power of CrewAI’s multi-agent framework with n8n’s workflow automation, we’ve created a system that can:

1. Analyze customer data to identify patterns and trends
2. Create detailed customer profiles
3. Generate highly personalized sales offers
4. Deliver those offers through professional, branded emails

As AI technology continues to evolve, we can expect these systems to become even more sophisticated, with deeper personalization and better targeting.

Resources:

GitHub repo with code example: sales-offer-crew