🇺🇸English

Google Workspace

Comprehensive AI agent skill for all Google Workspace document operations — Docs, Sheets, Slides, Drive, Gmail, Calendar, Chat, Forms, Admin SDK, and Apps Script — via official REST APIs.

When to use this skill

• Creating or editing Google Docs, Sheets, Slides
• Uploading, downloading, organizing Google Drive files and folders
• Sending/reading Gmail, managing labels and drafts
• Creating calendar events, inviting attendees, checking availability
• Posting Google Chat messages, managing spaces
• Building and reading Google Forms/surveys
• Provisioning/managing Google Workspace users (Admin SDK)
• Running automated workflows via Apps Script

Quick Setup

Step 1: Enable APIs in Google Cloud Console

# Install gcloud CLI (if not available)
brew install --cask google-cloud-sdk   # macOS
# Or: curl https://sdk.cloud.google.com | bash

# Enable all Workspace APIs
gcloud services enable docs.googleapis.com \
  sheets.googleapis.com slides.googleapis.com \
  drive.googleapis.com gmail.googleapis.com \
  calendar-json.googleapis.com chat.googleapis.com \
  forms.googleapis.com admin.googleapis.com \
  script.googleapis.com

Step 2: Install Python client library

pip install --upgrade \
  google-api-python-client \
  google-auth-httplib2 \
  google-auth-oauthlib

Step 3: Authenticate

# OAuth2 — interactive user auth (for accessing user's own data)
bash scripts/auth-setup.sh --oauth2 credentials.json

# Service Account — server-to-server (for automation/backend)
bash scripts/auth-setup.sh --service-account service-account-key.json

API Reference by Product

Google Docs

Endpoint : https://docs.googleapis.com/v1 Scope : https://www.googleapis.com/auth/documents

from googleapiclient.discovery import build

docs = build('docs', 'v1', credentials=creds)

# Create document
doc = docs.documents().create(body={'title': 'My Document'}).execute()
doc_id = doc['documentId']

# Read document
doc = docs.documents().get(documentId=doc_id).execute()
content = doc.get('body', {}).get('content', [])

# Edit: replace all text matching a pattern
requests = [{
    'replaceAllText': {
        'containsText': {'text': '{{name}}', 'matchCase': False},
        'replaceText': 'Alice'
    }
}]
docs.documents().batchUpdate(documentId=doc_id, body={'requests': requests}).execute()

# Insert text at position
requests = [{'insertText': {'location': {'index': 1}, 'text': 'Hello!\n'}}]
docs.documents().batchUpdate(documentId=doc_id, body={'requests': requests}).execute()

Key batchUpdate operations : insertText, deleteContentRange, replaceAllText, updateTextStyle, updateParagraphStyle, insertTable, insertInlineImage, createHeader, createFooter, createNamedRange

Google Sheets

Endpoint : https://sheets.googleapis.com/v4 Scope : https://www.googleapis.com/auth/spreadsheets

sheets = build('sheets', 'v4', credentials=creds)
ss = sheets.spreadsheets()

# Create spreadsheet
spreadsheet = ss.create(body={
    'properties': {'title': 'My Sheet'},
    'sheets': [{'properties': {'title': 'Data'}}]
}).execute()
sheet_id = spreadsheet['spreadsheetId']

# Write data
ss.values().update(
    spreadsheetId=sheet_id,
    range='Sheet1!A1',
    valueInputOption='USER_ENTERED',
    body={'values': [['Name', 'Score'], ['Alice', 95], ['Bob', 87]]}
).execute()

# Read data
result = ss.values().get(spreadsheetId=sheet_id, range='Sheet1!A:B').execute()
rows = result.get('values', [])

# Append rows
ss.values().append(
    spreadsheetId=sheet_id,
    range='Sheet1!A1',
    valueInputOption='USER_ENTERED',
    body={'values': [['Charlie', 91]]}
).execute()

# Batch update (format: freeze row 1, bold header)
ss.batchUpdate(spreadsheetId=sheet_id, body={'requests': [
    {'updateSheetProperties': {
        'properties': {'sheetId': 0, 'gridProperties': {'frozenRowCount': 1}},
        'fields': 'gridProperties.frozenRowCount'
    }},
    {'repeatCell': {
        'range': {'sheetId': 0, 'startRowIndex': 0, 'endRowIndex': 1},
        'cell': {'userEnteredFormat': {'textFormat': {'bold': True}}},
        'fields': 'userEnteredFormat.textFormat.bold'
    }}
]}).execute()

Google Slides

Endpoint : https://slides.googleapis.com/v1 Scope : https://www.googleapis.com/auth/presentations

slides = build('slides', 'v1', credentials=creds)

# Create presentation
presentation = slides.presentations().create(
    body={'title': 'My Presentation'}
).execute()
pres_id = presentation['presentationId']

# Read presentation
pres = slides.presentations().get(presentationId=pres_id).execute()
slide_ids = [s['objectId'] for s in pres.get('slides', [])]

# Add a new slide
slides.presentations().batchUpdate(presentationId=pres_id, body={'requests': [
    {'createSlide': {
        'insertionIndex': 1,
        'slideLayoutReference': {'predefinedLayout': 'TITLE_AND_BODY'}
    }}
]}).execute()

# Replace placeholder text
slides.presentations().batchUpdate(presentationId=pres_id, body={'requests': [
    {'replaceAllText': {
        'containsText': {'text': '{{title}}', 'matchCase': False},
        'replaceText': 'Q1 Report'
    }}
]}).execute()

# Get slide thumbnail
page_id = slide_ids[0]
thumb = slides.presentations().pages().getThumbnail(
    presentationId=pres_id,
    pageObjectId=page_id,
    thumbnailProperties_thumbnailSize='LARGE'
).execute()
image_url = thumb['contentUrl']

Google Drive

Endpoint : https://www.googleapis.com/drive/v3 Scope : https://www.googleapis.com/auth/drive

drive = build('drive', 'v3', credentials=creds)

# Create folder
folder = drive.files().create(body={
    'name': 'My Folder',
    'mimeType': 'application/vnd.google-apps.folder'
}).execute()
folder_id = folder['id']

# Upload file
from googleapiclient.http import MediaFileUpload
media = MediaFileUpload('report.pdf', mimetype='application/pdf')
file = drive.files().create(
    body={'name': 'report.pdf', 'parents': [folder_id]},
    media_body=media,
    fields='id'
).execute()

# Search files
results = drive.files().list(
    q="name contains 'report' and mimeType='application/pdf'",
    fields='files(id, name, modifiedTime)'
).execute()

# Share file
drive.permissions().create(
    fileId=file['id'],
    body={'type': 'user', 'role': 'reader', 'emailAddress': 'alice@example.com'},
    sendNotificationEmail=True
).execute()

# Export Google Doc to PDF
import io
from googleapiclient.http import MediaIoBaseDownload
request = drive.files().export_media(fileId=doc_id, mimeType='application/pdf')
fh = io.BytesIO()
downloader = MediaIoBaseDownload(fh, request)
done = False
while not done:
    _, done = downloader.next_chunk()
with open('document.pdf', 'wb') as f:
    f.write(fh.getvalue())

# Move file
drive.files().update(
    fileId=file['id'],
    addParents=folder_id,
    removeParents='root',
    fields='id, parents'
).execute()

# Copy file (e.g., from template)
copy = drive.files().copy(
    fileId='TEMPLATE_FILE_ID',
    body={'name': 'New Document from Template', 'parents': [folder_id]}
).execute()

Gmail

Endpoint : https://gmail.googleapis.com/gmail/v1 Scope : https://www.googleapis.com/auth/gmail.modify

import base64
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

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

# Send email
def send_email(to, subject, body):
    msg = MIMEText(body)
    msg['to'] = to
    msg['subject'] = subject
    raw = base64.urlsafe_b64encode(msg.as_bytes()).decode()
    gmail.users().messages().send(userId='me', body={'raw': raw}).execute()

send_email('alice@example.com', 'Hello', 'This is the body.')

# Send with attachment
msg = MIMEMultipart()
msg['to'] = 'alice@example.com'
msg['subject'] = 'Report'
msg.attach(MIMEText('Please find the report attached.'))
with open('report.pdf', 'rb') as f:
    from email.mime.application import MIMEApplication
    part = MIMEApplication(f.read(), Name='report.pdf')
    part['Content-Disposition'] = 'attachment; filename="report.pdf"'
    msg.attach(part)
raw = base64.urlsafe_b64encode(msg.as_bytes()).decode()
gmail.users().messages().send(userId='me', body={'raw': raw}).execute()

# Search emails
results = gmail.users().messages().list(
    userId='me', q='from:boss@company.com subject:urgent is:unread'
).execute()

# Read email
msg_id = results['messages'][0]['id']
msg = gmail.users().messages().get(userId='me', id=msg_id, format='full').execute()
subject = next(h['value'] for h in msg['payload']['headers'] if h['name'] == 'Subject')

# Create label and apply
label = gmail.users().labels().create(
    userId='me', body={'name': 'AI-Processed'}
).execute()
gmail.users().messages().modify(
    userId='me', id=msg_id,
    body={'addLabelIds': [label['id']], 'removeLabelIds': ['UNREAD']}
).execute()

# Create draft
raw_draft = base64.urlsafe_b64encode(MIMEText('Draft body').as_bytes()).decode()
gmail.users().drafts().create(
    userId='me', body={'message': {'raw': raw_draft}}
).execute()

# Set vacation responder
gmail.users().settings().updateVacation(
    userId='me',
    body={
        'enableAutoReply': True,
        'responseSubject': 'Out of Office',
        'responseBodyPlainText': 'I am OOO until Monday.',
        'startTime': '1704067200000',  # Unix ms
        'endTime':   '1704326400000'
    }
).execute()

Google Calendar

Endpoint : https://www.googleapis.com/calendar/v3 Scope : https://www.googleapis.com/auth/calendar

from datetime import datetime, timedelta
import pytz

calendar = build('calendar', 'v3', credentials=creds)

# Create event
event = calendar.events().insert(
    calendarId='primary',
    body={
        'summary': 'Team Standup',
        'description': 'Daily sync',
        'start': {'dateTime': '2026-03-15T09:00:00+09:00', 'timeZone': 'Asia/Seoul'},
        'end':   {'dateTime': '2026-03-15T09:30:00+09:00', 'timeZone': 'Asia/Seoul'},
        'attendees': [
            {'email': 'alice@example.com'},
            {'email': 'bob@example.com'},
        ],
        'conferenceData': {
            'createRequest': {'requestId': 'meeting-001', 'conferenceSolutionKey': {'type': 'hangoutsMeet'}}
        },
        'recurrence': ['RRULE:FREQ=DAILY;BYDAY=MO,TU,WE,TH,FR']
    },
    conferenceDataVersion=1
).execute()
meet_link = event.get('hangoutLink')

# List today's events
now = datetime.utcnow().isoformat() + 'Z'
end_of_day = (datetime.utcnow() + timedelta(hours=24)).isoformat() + 'Z'
events_result = calendar.events().list(
    calendarId='primary',
    timeMin=now, timeMax=end_of_day,
    singleEvents=True, orderBy='startTime'
).execute()
events = events_result.get('items', [])

# Check free/busy
body = {
    'timeMin': now,
    'timeMax': end_of_day,
    'items': [{'id': 'alice@example.com'}, {'id': 'bob@example.com'}]
}
freebusy = calendar.freebusy().query(body=body).execute()

# Block time / set OOO
calendar.events().insert(
    calendarId='primary',
    body={
        'summary': 'Out of Office',
        'eventType': 'outOfOffice',
        'start': {'date': '2026-03-20'},
        'end':   {'date': '2026-03-22'}
    }
).execute()

# Share calendar
calendar.acl().insert(
    calendarId='primary',
    body={'role': 'reader', 'scope': {'type': 'user', 'value': 'alice@example.com'}}
).execute()

Google Chat

Endpoint : https://chat.googleapis.com/v1 Scope : https://www.googleapis.com/auth/chat.messages

chat = build('chat', 'v1', credentials=creds)

# Send message to a space
space_name = 'spaces/SPACE_ID'  # From Chat URL
chat.spaces().messages().create(
    parent=space_name,
    body={
        'text': 'Hello from AI agent! 🤖',
        'cards_v2': [{
            'cardId': 'card1',
            'card': {
                'header': {'title': 'Update', 'subtitle': 'Automated report'},
                'sections': [{'widgets': [{'textParagraph': {'text': 'Task completed.'}}]}]
            }
        }]
    }
).execute()

# Create a new space
space = chat.spaces().create(
    body={
        'spaceType': 'SPACE',
        'displayName': 'Project Alpha'
    }
).execute()

# List spaces
spaces = chat.spaces().list().execute()

# Add member to space
chat.spaces().members().create(
    parent=space['name'],
    body={'member': {'name': 'users/alice@example.com', 'type': 'HUMAN'}}
).execute()

# Find or create direct message
dm = chat.spaces().findDirectMessage(name='users/alice@example.com').execute()

Google Forms

Endpoint : https://forms.googleapis.com/v1 Scope : https://www.googleapis.com/auth/forms.body

forms = build('forms', 'v1', credentials=creds)

# Create form
form = forms.forms().create(body={
    'info': {'title': 'Customer Feedback Survey', 'documentTitle': 'Customer Feedback'}
}).execute()
form_id = form['formId']

# Add questions
forms.forms().batchUpdate(formId=form_id, body={'requests': [
    {
        'createItem': {
            'item': {
                'title': 'How satisfied are you?',
                'questionItem': {
                    'question': {
                        'required': True,
                        'scaleQuestion': {
                            'low': 1, 'high': 5,
                            'lowLabel': 'Not satisfied', 'highLabel': 'Very satisfied'
                        }
                    }
                }
            },
            'location': {'index': 0}
        }
    },
    {
        'createItem': {
            'item': {
                'title': 'Any comments?',
                'questionItem': {
                    'question': {
                        'required': False,
                        'textQuestion': {'paragraph': True}
                    }
                }
            },
            'location': {'index': 1}
        }
    }
]}).execute()

# Get form responses
responses = forms.forms().responses().list(formId=form_id).execute()
for r in responses.get('responses', []):
    for qid, ans in r.get('answers', {}).items():
        print(qid, ans.get('textAnswers', {}).get('answers', []))

Admin SDK — Directory API

Endpoint : https://admin.googleapis.com Scope : https://www.googleapis.com/auth/admin.directory.user Requires : Service account with domain-wide delegation

from google.oauth2 import service_account

SA_FILE = 'service-account.json'
SCOPES  = ['https://www.googleapis.com/auth/admin.directory.user',
           'https://www.googleapis.com/auth/admin.directory.group']
creds = service_account.Credentials.from_service_account_file(
    SA_FILE, scopes=SCOPES
).with_subject('admin@yourdomain.com')

admin = build('admin', 'directory_v1', credentials=creds)

# Create user
admin.users().insert(body={
    'primaryEmail': 'newuser@yourdomain.com',
    'name': {'givenName': 'New', 'familyName': 'User'},
    'password': 'TemporaryPassword123!',
    'changePasswordAtNextLogin': True
}).execute()

# List users
users_result = admin.users().list(domain='yourdomain.com', maxResults=100).execute()
for user in users_result.get('users', []):
    print(user['primaryEmail'], user.get('suspended', False))

# Suspend user
admin.users().update(
    userKey='user@yourdomain.com',
    body={'suspended': True}
).execute()

# Add user to group
admin.members().insert(
    groupKey='team@yourdomain.com',
    body={'email': 'user@yourdomain.com', 'role': 'MEMBER'}
).execute()

# List groups
groups = admin.groups().list(domain='yourdomain.com').execute()

Apps Script API

Endpoint : https://script.googleapis.com/v1 Scope : https://www.googleapis.com/auth/script.projects

script = build('script', 'v1', credentials=creds)

# Run a deployed function
response = script.scripts().run(
    scriptId='DEPLOYED_SCRIPT_ID',
    body={
        'function': 'myFunction',
        'parameters': ['arg1', 42]
    }
).execute()
result = response.get('response', {}).get('result')

Common Automation Patterns

Pattern 1: Create Document from Template

def create_doc_from_template(drive, docs, template_id, replacements, dest_folder_id=None):
    """Clone a template Google Doc and fill in placeholders."""
    body = {'name': replacements.get('{{title}}', 'New Document')}
    if dest_folder_id:
        body['parents'] = [dest_folder_id]
    copy = drive.files().copy(fileId=template_id, body=body).execute()
    new_id = copy['id']
    requests = [
        {'replaceAllText': {'containsText': {'text': k, 'matchCase': False}, 'replaceText': v}}
        for k, v in replacements.items()
    ]
    if requests:
        docs.documents().batchUpdate(documentId=new_id, body={'requests': requests}).execute()
    return new_id

Pattern 2: Bulk Append to Spreadsheet

def bulk_append_rows(sheets, spreadsheet_id, sheet_name, rows):
    """Append multiple rows to a sheet in one API call."""
    sheets.spreadsheets().values().append(
        spreadsheetId=spreadsheet_id,
        range=f'{sheet_name}!A1',
        valueInputOption='USER_ENTERED',
        insertDataOption='INSERT_ROWS',
        body={'values': rows}
    ).execute()

Pattern 3: Create Meeting Notes Document

def create_meeting_notes(calendar, drive, docs, event_id):
    """Create a Google Doc for meeting notes and share with attendees."""
    event = calendar.events().get(calendarId='primary', eventId=event_id).execute()
    attendees = [a['email'] for a in event.get('attendees', [])]
    title = f"Meeting Notes: {event['summary']} — {event['start'].get('dateTime', event['start'].get('date'))}"
    doc = docs.documents().create(body={'title': title}).execute()
    doc_id = doc['documentId']
    for email in attendees:
        drive.permissions().create(
            fileId=doc_id,
            body={'type': 'user', 'role': 'writer', 'emailAddress': email},
            sendNotificationEmail=True
        ).execute()
    return doc_id

Pattern 4: Form Response to Sheet

def sync_form_to_sheet(forms, sheets, form_id, spreadsheet_id):
    """Sync all form responses to a Google Sheet."""
    responses = forms.forms().responses().list(formId=form_id).execute()
    form_data = forms.forms().get(formId=form_id).execute()
    questions = {
        item['itemId']: item.get('title', '')
        for item in form_data.get('items', [])
        if 'questionItem' in item
    }
    headers = ['Timestamp'] + list(questions.values())
    rows = [headers]
    for resp in responses.get('responses', []):
        row = [resp.get('createTime', '')]
        for qid in questions:
            ans = resp.get('answers', {}).get(qid, {})
            text_ans = ans.get('textAnswers', {}).get('answers', [{}])
            row.append(text_ans[0].get('value', '') if text_ans else '')
        rows.append(row)
    sheets.spreadsheets().values().update(
        spreadsheetId=spreadsheet_id,
        range='Sheet1!A1',
        valueInputOption='USER_ENTERED',
        body={'values': rows}
    ).execute()

Rate Limits & Best Practices

import time
from googleapiclient.errors import HttpError

def api_call_with_retry(func, *args, max_retries=5, **kwargs):
    """Wrapper that retries on 429/503 with exponential backoff."""
    for attempt in range(max_retries):
        try:
            return func(*args, **kwargs).execute()
        except HttpError as e:
            if e.resp.status in (429, 503) and attempt < max_retries - 1:
                wait = (2 ** attempt) + 0.1
                print(f"Rate limit hit, waiting {wait:.1f}s...")
                time.sleep(wait)
            else:
                raise

Scopes Reference

References

• Google Workspace Developer Hub
• Google Docs API Reference
• Google Sheets API Reference
• Google Slides API Reference
• Google Drive API v3 Reference
• Gmail API Reference
• Google Calendar API Reference
• Google Chat API Reference
• Google Forms API Reference
• Admin SDK Directory API Reference
• Apps Script REST API
• Auth Overview & Credentials Setup
• Enable APIs Guide

Weekly Installs

361

Repository

supercent-io/sk…template

GitHub Stars

88

First Seen

Mar 12, 2026

Security Audits

Gen Agent Trust HubPassSocketPassSnykFail

Installed on

gemini-cli319

codex312

opencode303

github-copilot300

cursor300

kimi-cli299