Comprehensive Guide to Using Gmail API with OpenAI for Customer Service Automation

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setting Up Gmail API
    1. Create a Google Cloud Project
    2. Enable Gmail API
    3. Download Credentials
  4. Setting Up OpenAI API
  5. Implementation
    1. Authenticate Gmail API
    2. Authenticate OpenAI API
    3. Read Emails
    4. Generate Responses
    5. Send Responses
  6. Conclusion
  7. Further Resources

NOTE: Once you feel comfortable with this set up, see “SORTING CUSTOMER EMAILS” section near the bottom for info on how to sort customer emails with OpenAI in order to take specific actions. For example sort “refund” emails, “cancel subscription” emails etc.


Customer service is a critical aspect of any business, but it can be time-consuming. This guide aims to help you set up an automated system for reading and responding to customer emails using the Gmail API and OpenAI’s GPT-4 API.


  • Basic understanding of Python programming
  • A Google Account
  • OpenAI API key
  • Python environment with pip installed

Setting Up Gmail API

Create a Google Cloud Project

  1. Navigate to the Google Cloud Console.
  2. Create a new project by clicking the “New Project” button.

Enable Gmail API

  1. In your Google Cloud project, navigate to the “APIs & Services > Library.”
  2. Search for “Gmail API” and enable it.

Download Credentials

  1. Create credentials for your project by navigating to “APIs & Services > Credentials.”
  2. Create a new OAuth client ID and download the JSON file. This will contain the client_id and client_secret needed for authentication.

Setting Up OpenAI API

  1. Navigate to the OpenAI website and sign up for an API key if you haven’t already.
  2. Store the API key securely; you’ll need it to authenticate your application.


Authenticate Gmail API

Use the google-auth and google-auth-oauthlib libraries to authenticate the Gmail API.

from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow

# Initialize the OAuth2 flow
flow = InstalledAppFlow.from_client_secrets_file('path/to/credentials.json', ['', ''])

# Run the flow and get the credentials
credentials = flow.run_local_server(port=0)

Authenticate OpenAI API

Use the OpenAI Python package to authenticate the OpenAI API.

import openai

openai.api_key = "your_OpenAI_API_key"

Read Emails

Use the Gmail API to read unread emails. The following code snippet fetches unread emails:

from googleapiclient.discovery import build

service = build('gmail', 'v1', credentials=credentials)

# Fetch unread emails
results = service.users().messages().list(userId='me', labelIds=['INBOX'], q="is:unread").execute()
messages = results.get('messages', [])

Generate Responses

Use OpenAI’s GPT-4 API to generate responses to the unread emails.

for message in messages:
    msg = service.users().messages().get(userId='me', id=message['id']).execute()
    email_data = msg['payload']['headers']

    for values in email_data:
        name = values['name']
        if name == 'From':
            from_email = values['value']

    # Generate a response using OpenAI API
    response = openai.Completion.create(
      prompt="Respond to the customer query: {}".format(msg['snippet']),

    generated_response = response.choices[0].text.strip()

Send Responses

Use the Gmail API to send the generated responses back to the customer.

from email.mime.text import MIMEText
import base64

def create_message(sender, to, subject, message_text):
    message = MIMEText(message_text)
    message['to'] = to
    message['from'] = sender
    message['subject'] = subject
    return {'raw': base64.urlsafe_b64encode(message.as_string().encode()).decode()}

# Create email
email = create_message('[email protected]', from_email, 'Re: Customer Service', generated_response)

# Send email
service.users().messages().send(userId='me', body=email).execute()


You’ve successfully set up an automated system to read and respond to customer service emails using the Gmail API and OpenAI’s GPT-4. This system can significantly reduce the time and effort spent on customer service tasks.

Further Resources

Disclaimer: This guide is for educational purposes and should be used responsibly. Always adhere to ethical guidelines and laws related to email communication and data privacy.


Creating a system to sort customer support emails using Gmail API and OpenAI’s API involves several steps. Below is a guide outlining the entire process. This guide assumes you have basic familiarity with Python.


  • Python installed
  • Gmail API credentials
  • OpenAI API key

Step 1: Setting Up Gmail API

  1. Go to the Google Developer Console and create a new project.
  2. Enable the Gmail API and download the credentials.json file.
  3. Install the Google Client Library:
    bash pip install --upgrade google-api-python-client
  4. Use the credentials to authenticate and access Gmail. Save the token for future use.

Step 2: Setting Up OpenAI API

  1. Visit the OpenAI website and obtain your API key.
  2. Install the OpenAI package:
    bash pip install openai

Step 3: Fetch Emails from Gmail

Use the Gmail API to fetch emails that are in the customer support folder or have a specific label.

from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
from googleapiclient.discovery import build

# Load Gmail API credentials and create a service object
creds = None
if creds and not creds.valid:
    if creds.expired and creds.refresh_token:
    flow = InstalledAppFlow.from_client_secrets_file('credentials.json', [''])
    creds = flow.run_local_server(port=0)
    with open('token.json', 'w') as token:

service = build('gmail', 'v1', credentials=creds)

# Fetch emails
results = service.users().messages().list(userId='me', labelIds=['Label_12345']).execute()
messages = results.get('messages', [])

Step 4: Sort Emails Using OpenAI API

Use OpenAI’s API to sort emails based on their content.

import openai

openai.api_key = "your-openai-api-key"

def sort_email(email_body):
    prompt = f"This is a customer email: {email_body}\n\nIs this email about:"
    choices = ["asking for refunds", "canceling monthly subscription", "how to login", "status of their order"]

    response = openai.Completion.create(

    output = response.choices[0].text.strip()
    return output

for message in messages:
    email_body = "Fetch email body using Gmail API"  # Simplified, you'll need to extract the email body from the Gmail API response
    category = sort_email(email_body)
    print(f"Email is about: {category}")

Step 5: Take Action Based on Sorting

Based on the category you get from OpenAI, you can now sort the emails into different folders or perform other actions.

That’s a high-level overview of how you can use the Gmail and OpenAI APIs to automatically sort customer support emails. You’ll need to handle edge cases and possibly train the OpenAI model more specifically to your needs. Please note that API keys and tokens should be kept secure, and you should follow best practices for secure coding.

Google Cloud Platform (GCP) instead of the Google Developer Console

You can use Google Cloud Platform (GCP) instead of the Google Developer Console for setting up the Gmail API, as they are essentially part of the same ecosystem. In GCP, you can enable the Gmail API, generate credentials, and manage your API usage in a similar way as you would in the Google Developer Console. Here’s how you can do it:

Step 1: Access Google Cloud Console

  1. Go to the Google Cloud Console.
  2. Create a new project or select an existing one.

Step 2: Enable Gmail API

  1. Navigate to “APIs & Services” > “Dashboard.”
  3. Search for “Gmail API” and enable it.

Step 3: Generate Credentials

  1. Go back to “APIs & Services” > “Credentials.”
  2. Click on “Create credentials” and follow the prompts to generate a credentials.json file.

From this point on, you can proceed with the guide I provided earlier, starting with installing the Google Client Library and setting up the Gmail API in your Python code. The credentials generated from the Google Cloud Console can be used in the same way as those from the Google Developer Console.

Remember to secure your API keys and tokens and adhere to best practices for coding securely.