How to Connect Google Sheets to LangGraph

Building intelligent agents that can interact with the world's most popular spreadsheet application opens up a universe of automation possibilities. By connecting LangGraph's stateful, multi-agent workflows with a Google Sheet, you can create systems that read data, perform analysis, and write back results, all without manual intervention. This guide will walk you through every step of the process, from setting up a Google Cloud project to deploying a Python agent that can control your spreadsheets.

Graphed

Build AI Agents for Marketing

Build virtual employees that run your go to market. Connect your data sources, deploy autonomous agents, and grow your company.

Build Your First Agent

Why Connect Google Sheets and LangGraph? Understanding the Power-Up

At first glance, pairing a complex AI framework with a simple spreadsheet might seem like overkill, but the synergy between them is incredibly powerful. LangGraph provides the "brain" - the logic for creating complex, multi-step tasks with memory and branching. Google Sheets acts as a simple, universally understood, and highly accessible database for this brain to work with.

This combination unlocks practical automations for everyday business needs. Imagine agents that can:

• Perform Automated Reporting: An agent could run every Monday morning, access a Google Sheet with raw marketing campaign data, calculate week-over-week performance changes, and write a concise summary in a separate 'Reports' tab.
• Enrich Data on Autopilot: You could have an agent that reads a list of new leads from a sheet, uses tools to find their company size and website, and then updates the corresponding rows with this enriched data.
• Manage Project Workflows: An agent can monitor a project plan in Google Sheets. When a task's status is changed to "Ready for Review," it could automatically notify the relevant person via another integrated service and update the sheet's status to "Notified."
• Generate Personalized Content: Feed an agent a Google Sheet with a list of blog topics and keywords. It can then research each topic, generate a draft, and update the sheet with a link to the draft and a status of "Draft Completed."

These aren't futuristic ideas, they are achievable workflows that you can build by connecting these two powerful free tools.

Step 1: Setting Up Your Google Cloud Project and API Access

Before writing a single line of code, we need to create a way for our application to securely authenticate with Google's services. This is done through a Google Cloud project and a "service account," which is like a special user account designed for scripts and applications.

Creating a Google Cloud Project

1. Navigate to the Google Cloud Console.
2. In the top left, click the project selection dropdown and click "New Project".
3. Give your project a descriptive name, like "LangGraph Sheets Connection," and click "Create".

AI Agents for Marketing

Crash Course

Graphed

Free PDF · the crash course

AI Agents for Marketing Crash Course

Learn how to deploy AI marketing agents across your go-to-market — the best tools, prompts, and workflows to turn your data into autonomous execution without writing code.

Download the PDF

Enabling the Necessary APIs

A new project doesn't have any APIs enabled by default. We need to manually activate the APIs for Google Sheets and Google Drive to allow our code to interact with them.

1. Once your project is created and selected, go to the navigation menu (the hamburger icon ☰) and select "APIs & Services" > "Library".
2. Search for "Google Sheets API", select it from the results, and click "Enable".
3. Search for "Google Drive API", select it, and click "Enable". (The Drive API is often needed for managing permissions and access).

After enabling, you will be redirected to the API's dashboard. You're now ready to create credentials.

Creating Service Account Credentials

1. In the "APIs & Services" section, go to the "Credentials" tab on the left.
2. Click "+ CREATE CREDENTIALS" and choose "Service Account".
3. Name your service account something clear, like "langgraph-sheet-manager." The Service Account ID will populate automatically. Add a brief description and click "CREATE AND CONTINUE."
4. For role access, keep it simple with "Editor". Click continue. Note: For production, grant only necessary permissions.
5. Skip the "Grant users access" step and click "Done."
6. On the Credentials page, click on your service account's email. Go to the "KEYS" tab, click "ADD KEY", select "Create new key".
7. Choose JSON and click "Create". This will download a JSON file—save it securely as credentials.json. Do not share or commit this file publicly.

Step 2: Preparing Your Google Sheet for Access

Create a Google Sheet titled "Project Task List" with columns: Task Name, Assigned To, Due Date, Status. Populate a few rows as needed.

Open your credentials.json and find the client_email. It will look like langgraph-sheet-manager@your-project-id.iam.gserviceaccount.com.

Share your Google Sheet with that email address:

1. Open the sheet and click "Share" button.
2. Paste the client_email into "Add people and groups."
3. Set permission to "Editor".
4. Uncheck "Notify people" and click "Share."

Your sheet is now authorized for access by your agent.

Step 3: Building the Python Environment and Tools

Install required Python libraries:

pip install langgraph langchain_google_genai gspread google-auth-oauthlib beautifulsoup4 notebook

Create credentials.json in your project directory with the downloaded JSON credentials.

Graphed

Build AI Agents for Marketing

Build virtual employees that run your go to market. Connect your data sources, deploy autonomous agents, and grow your company.

Build Your First Agent

Creating Functions to Interact with Google Sheets

The core functions are decorated with @tool for use by LangGraph.

import gspread
from google.oauth2.service_account import Credentials
from langchain_core.tools import tool

# Define the scope
SCOPES = [
    'https://www.googleapis.com/auth/spreadsheets',
    'https://www.googleapis.com/auth/drive'
]

# Authorize gspread
credentials = Credentials.from_service_account_file("credentials.json", scopes=SCOPES)
gc = gspread.authorize(credentials)

@tool
def read_sheet(spreadsheet_id: str, sheet_name: str) -> list:
    """Reads all data from a worksheet given its ID."""
    spreadsheet = gc.open_by_key(spreadsheet_id)
    worksheet = spreadsheet.worksheet(sheet_name)
    return worksheet.get_all_records()

@tool
def update_cell(spreadsheet_id: str, sheet_name: str, a1_notation, value: str) -> str:
    """Updates a specific cell identified by A1 notation."""
    spreadsheet = gc.open_by_key(spreadsheet_id)
    worksheet = spreadsheet.worksheet(sheet_name)
    worksheet.update_acell(a1_notation, value)
    return "SUCCESS"

@tool
def add_row(spreadsheet_id: str, sheet_name: str, values: list):
    """Appends a new row to the sheet."""
    spreadsheet = gc.open_by_key(spreadsheet_id)
    worksheet = spreadsheet.worksheet(sheet_name)
    worksheet.append_row(values)
    return "SUCCESS"

Ensure you replace 'your-sheet-name-here' with your actual sheet name and spreadsheet_id with your sheet's ID.

Step 4: Putting It All Together with LangGraph

Define system state, utility methods, nodes, and connect them into a graph.

import operator
from typing import Annotated, TypedDict
from langchain_core.messages import BaseMessage, HumanMessage
from langchain_google_genai import ChatGoogleGenerativeAI
from langgraph.graph import StateGraph, END

# Set up the model
model = ChatGoogleGenerativeAI(model="gemini-pro", temperature=0)
model_with_tools = model.bind_tools(tools)

# Define state
class AgentState(TypedDict):
    messages: Annotated[list[BaseMessage], operator.add]

# Tool node
def tool_node(state):
    last_message = state["messages"][-1]
    tool_calls = getattr(last_message, 'tool_calls', None)
    if tool_calls:
        for call in tool_calls:
            # Process calls
            pass

def call_llm(state):
    messages = state["messages"]
    response = model_with_tools.invoke(messages)
    return {"messages": [response]}

def should_continue(state: AgentState):
    if "tool_calls" in state["messages"][-1].additional_kwargs:
        return "tools"
    return "end"

workflow = StateGraph(AgentState)
workflow.add_node("agent", call_llm)
workflow.add_node("tools", tool_node)
workflow.add_conditional_edges(
    "agent", should_continue, {"tools": "tools", "end": END}
)

workflow.add_edge("tools", "agent")
workflow.set_entry_point("agent")
app = workflow.compile()

AI Agents for Marketing

Crash Course

Graphed

Free PDF · the crash course

AI Agents for Marketing Crash Course

Learn how to deploy AI marketing agents across your go-to-market — the best tools, prompts, and workflows to turn your data into autonomous execution without writing code.

Download the PDF

Step 4: Response Sequence Example

from langchain_core.messages import HumanMessage

app.invoke({"messages": [HumanMessage(content="Update the cell B2 with Peter in team-management sheet, remember the spreadsheet key is [SPREADSHEET-ID]")]})

# Expected output:
"""
{'messages': [HumanMessage(content='Update the cell B2 with the "Peter" in team-management sheet, make sure using this key  "1Vdp...rEU " during process'), 
  AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call__xyz...', 'function': {'arguments': '{"s_id":"1Vd...EU","s_name":..." Peter"}', 'name': 'update_cell'}, 'type': 'function'}]}, response_metadata={'finish_reason': 'TOOL_CALLS'}, tool_calls=[{'name': 'update_cell', 'args': {'s_id': '...', 'args': {...}}]})]}
]
"""

This illustrates how the agent processes the request, invokes update_cell, and updates the sheet.

Final Thoughts

Connecting Google Sheets to LangGraph via Python allows for active, intelligent automation. We've covered setup from Google Cloud credentials to Python tools and agent assembly.

For quick data access and question answering without coding, tools like Graphed now enable connecting directly to sources like Google Sheets, Shopify, and Analytics with a few clicks—making insights accessible without coding skills.