Google Classroom

Live

OAUTH 2.0

COURSEWORK

Productivity

Google Classroom gives your agent courses and coursework: list rosters, create assignments and announcements, grade and return student submissions, and manage guardians and invitations.

  • Per-user credentials: each call uses the actual user's token, never a shared bot.
  • Encrypted per-tenant vault: AES-256, resolved at request time, never in LLM context.
  • Scoped before every call: pre-call scope check, 90-day SIEM-exportable audit chain.
Google Classroom
agent · Acme Q3
Run
Which students have not turned in the Unit 3 essay in Biology 101?
S
googleclassroom_student_submissions_list
126ms
Classroom agent
7 of 28 submissions for the Unit 3 essay are not turned in yet. 2 more are turned in and waiting for a grade.
Sources: Google Classroom, 28 submissions
googleclassroom
28 submissions
18:29
Message Claude...

Tools your classroom agent reaches for on Google Classroom, scoped per user.

CALL ANY TOOL
76 tools for courses and coursework in Google Classroom: rosters, assignments, materials, rubrics, announcements, topics, student submissions and grades, guardians, and invitations.
googleclassroom_announcement_create
Create announcement
Create a new announcement (stream post) in a Google Classroom course. Returns the created announcement, including its Classroom-assigned ID, state, and creation time. Use this to post a new update to the class stream; use announcement_patch to edit an existing announcement instead of recreating it. Announcements are stream posts, distinct from topics which are organizational labels used to group coursework.
Parameters
Name
Type
Required
Description
course_id
string
Required
Identifier of the course to post the announcement in. This can be either the Classroom-assigned course ID (a numeric string) or an alias (e.g. prefixed with 'd:' for a domain-scoped alias or 'p:' for a project-scoped alias).
text
string
Required
Body text of the announcement, shown in the Classroom stream. Must be a valid UTF-8 string of no more than 30,000 characters. Example: 'Reminder: submit your project proposal by Friday.'
assignee_mode
string
Optional
Controls which students can view this announcement. ALL_STUDENTS makes it visible to every student in the course; INDIVIDUAL_STUDENTS restricts visibility to only the students listed in individual_student_ids. If unspecified, Classroom defaults to ALL_STUDENTS. Example: ALL_STUDENTS. One of: `ASSIGNEE_MODE_UNSPECIFIED`, `ALL_STUDENTS`, `INDIVIDUAL_STUDENTS`.
individual_student_ids
array
Optional
Classroom user IDs of the students who should have access to this announcement. Only applied when assignee_mode is INDIVIDUAL_STUDENTS; ignored otherwise. Example: 106783094529935604519.
materials
string
Optional
Additional materials to attach to the announcement, as a JSON-encoded array of Material objects (each with one of driveFile, youtubeVideo, link, or form). Announcements support at most 20 material items. Example: [{"link":{"url":"https://example.com/reading.pdf"}}].
scheduled_time
string
Optional
RFC3339 UTC timestamp at which Classroom should automatically publish this announcement. Must be paired with state=DRAFT, Classroom rejects a scheduled_time on an announcement that publishes immediately (the default state when state is omitted is PUBLISHED, not DRAFT). Example: 2026-09-01T15:00:00.000Z.
state
string
Optional
Status of the announcement. PUBLISHED makes it immediately visible to students; DRAFT keeps it hidden until published. If unspecified, Classroom defaults to PUBLISHED. Example: PUBLISHED. One of: `ANNOUNCEMENT_STATE_UNSPECIFIED`, `PUBLISHED`, `DRAFT`, `DELETED`.
googleclassroom_announcement_delete
Delete announcement
googleclassroom_announcement_get
Get announcement
googleclassroom_announcement_modify_assignees
Announcement modify assignees
googleclassroom_announcement_patch
Announcement patch
googleclassroom_announcements_list
List announcements
googleclassroom_course_create
Create course
googleclassroom_course_delete
Delete course
googleclassroom_course_get_grading_period_settings
Course get grading period settings
googleclassroom_course_update
Update course
googleclassroom_coursework_list
List coursework
googleclassroom_coursework_material_create
Create coursework material
googleclassroom_coursework_material_delete
Delete coursework material
googleclassroom_coursework_material_patch
Coursework material patch
googleclassroom_coursework_rubric_get
Get coursework rubric
googleclassroom_coursework_rubric_patch
Coursework rubric patch
googleclassroom_guardian_invitations_list
List guardian invitations
googleclassroom_invitation_accept
Invitation accept
googleclassroom_invitation_create
Create invitation
googleclassroom_invitation_delete
Delete invitation
googleclassroom_invitation_get
Get invitation
googleclassroom_student_create
Create student
googleclassroom_student_delete
Delete student
googleclassroom_student_group_member_create
Create student group member
googleclassroom_student_group_member_delete
Delete student group member
googleclassroom_student_group_members_list
List student group members
googleclassroom_student_group_patch
Student group patch
googleclassroom_student_submission_reclaim
Student submission reclaim
googleclassroom_students_list
List students
googleclassroom_teacher_get
Get teacher

For more tools, view docs.

Build your Agent
Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.
Python · LlamaIndex
import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// Google Classroom tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["googleclassroom"], toolNames: [
    "googleclassroom_courses_list",
    "googleclassroom_coursework_list",
    "googleclassroom_student_submissions_list"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Which students have not turned in the Unit 3 essay?" }] });
import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["googleclassroom"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "Which students have not turned in the Unit 3 essay?" }],
  tools,
});

// Execute the tool call with the user's vaulted Google Classroom token
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");
import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["googleclassroom"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Which students have not turned in the Unit 3 essay?" }],
  tools,
});

// Tool call runs with the user's vaulted Google Classroom token
await sk.tools.executeTool(msg.content, "user_123");
import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["googleclassroom"] }, pageSize: 100,
});

const agent = new Agent({
  name: "classroom_agent",
  model: "gemini-2.5-pro",
  instruction: "Google Classroom tools scoped to this user",
  tools,
});

await agent.run("Which students have not turned in the Unit 3 essay?");
Try these prompts
Copy any prompt into your agent. Each maps directly to a Google Classroom tool. Click to copy, paste into your agent, done.
Courses and rosters
Copy the prompt
Copied
List the active courses I teach.
Copy the prompt
Copied
Show the students enrolled in Biology 101.
Copy the prompt
Copied
Invite this teacher to co-teach my Algebra course.
Coursework
Copy the prompt
Copied
Create an assignment for Unit 4 in Biology 101 due next Friday.
Copy the prompt
Copied
Post an announcement that tomorrow's quiz moves to Thursday.
Copy the prompt
Copied
List the course materials under the Lab Safety topic.
Grading
Copy the prompt
Copied
Which students have not turned in the Unit 3 essay?
Copy the prompt
Copied
Set a grade of 92 on this student's submission.
Copy the prompt
Copied
Return the graded Unit 3 essays to students.
SEE HOW AUTH WORKS
Each user signs in to Google Classroom once; Scalekit stores and refreshes their tokens. Credentials stay vaulted, every call is scope checked, and every action is logged.
1
Authorize
Your user connects
Google Classroom
once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access
Who:
user ‘A’
when:
Once per user
access:
Limited to user
2
Store
Their
Google Classroom
token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection
vault:
encrypted
scope:
per-user
tokens:
auto-refreshed
3
Resolve
When your agent calls a
Google Classroom
tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs
speed:
~40ms
check:
before every call
seen by:
nobody
4
Audit
Every
Google Classroom
tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it
history:
90 days
export:
SIEM-ready
logged:
every call
Test other agents
See the same per-user auth pattern across other productivity connectors.
People Ops and HR teams
Performance review collector
Collects review feedback from Airtable and Google Forms scoped to each manager's direct reports, writes per-employee summaries to Notion, and DMs the manager a Slack digest.
Support and Ops Teams
Meeting prep
Pulls agenda, participant context, and open action items before every meeting.
Support and Ops Teams
Email-to-calendar agent
Reads scheduling intent out of Gmail threads, resolves the times everyone actually has free, and creates the event on the user's own Google Calendar. No shared service account.
Engineering Teams
Engineering standup agent
Pulls commits from GitHub and GitLab, tracks issue movement in Jira, and posts a per-engineer standup brief to Slack. Each engineer's activity is read on their own delegated OAuth.
Test other agents
See the same per-user auth pattern across other productivity connectors.
PEOPLE OPS
Performance review collector agent
Collect review feedback from Airtable and Google Forms per manager, summarise each report in Notion, and DM the digest in Slack.
OPS
Meeting prep agent
Assemble the agenda, HubSpot attendee history, and open action items from Gmail before every meeting on the calendar.
OPS
Email-to-calendar scheduling agent
Read scheduling intent out of Gmail threads, resolve mutual free time, and create the Google Calendar event.
ENGINEERING
Engineering standup agent
Pull commits from GitHub and GitLab, track Jira issue movement, and post a per-engineer standup brief to Slack.
Why Scalekit
Secure your agent's access. Connectors ship in minutes
01.
Shared tokens break per-user analytics
A shared Google Classroom token looks fine in a demo. In production every grade and announcement looks like one service account, and you cannot tell which user triggered it. Scalekit resolves the credential of the actual user who triggered the agent, never a shared bot.
// shared token
audit → bot_service_account

// scalekit
audit → user_abc ✓
02.
Authentication is not authorization
03.
Multi-tenancy is architectural
04.
Google Classroom today. Ten connectors tomorrow.
“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”
Venu Madhav Kattagoni
Head of Engineering / Von
FAQs
Frequently Asked Questions
Does the agent access Google Classroom as the user or through a shared service account?
As the user. Each user signs in to Google Classroom once, and Scalekit stores and refreshes their tokens. The agent only sees the courses and rosters that user is permitted to view, and every action is attributed to them in your audit trail.
Where is the Google Classroom OAuth token stored?
In Scalekit's managed AES-256 token vault, namespaced per tenant. Refresh is automatic. Revocation is a single dashboard action. Credentials never appear in prompts, logs, or LLM context.
Can I limit what the agent does in Google Classroom?
Yes. Filter by tool name in listScopedTools to expose only what you want, for example the list and get tools without the delete tools. Scalekit also enforces scope checks before every API call.
What happens when a user revokes Google Classroom access?
The connection is invalidated on the next tool call. Subsequent requests for that user fail closed with a clear error. Other users in the tenant remain unaffected. The event is logged for audit.
Can the agent grade and return student work?
Yes, when the signed-in user teaches the course. googleclassroom_student_submission_patch sets or updates a grade, and googleclassroom_student_submission_return returns graded work to the student. Turn-in and reclaim act as the student who owns the submission.
Start in your coding agent
Up and running in one command
Install the Scalekit skill in your editor of choice. Connector, auth, tools, prompt, all wired up
Claude Code REPL
/plugin marketplace add scalekit-inc/claude-code-authstack
/plugin install agentkit@scalekit-auth-stack
Cursor Code REPL
# ~/.cursor/mcp.json
{
""mcpServers"": {
""googleclassroom"": {
""url"": ""https://mcp.scalekit.com/googleclassroom"",
""headers"": { ""Authorization"": ""Bearer $SCALEKIT_TOKEN"" }
}
}
}
Codex Code REPL
# ~/.codex/config.toml
[mcp_servers.googleclassroom]
url = ""https://mcp.scalekit.com/googleclassroom""
auth_env = ""SCALEKIT_TOKEN""
Copilot Code REPL
# .vscode/mcp.json
{
""servers"": {
""googleclassroom"": {
""url"": ""https://mcp.scalekit.com/googleclassroom"",
""type"": ""http""
}
}
}