# How to connect Google Classroom to OpenClaw (no API keys)

> Connect Google Classroom to OpenClaw with ClawLink in one click — 62 tools your AI agent can call from chat via hosted OAuth. No API keys, no manual setup.

Web version: https://claw-link.dev/openclaw/google-classroom

The usual route to Google Classroom access for OpenClaw is an MCP server you configure and keep running, plus your own OAuth app or API keys. ClawLink gives OpenClaw a more practical Google Classroom setup: install one ClawHub skill, connect Google Classroom in the browser, and OpenClaw can call real Google Classroom actions from any chat surface with no auth, token refresh, or tool wiring to build yourself.

**Start here:** install the ClawLink plugin (`openclaw plugins install clawhub:clawlink-plugin`), pair it in the browser, then connect the app in the ClawLink dashboard. The interactive install prompt is on the web version of this page: https://claw-link.dev/openclaw/google-classroom

## Setup

It takes three steps to connect OpenClaw to Google Classroom.

1. **Install ClawLink** — add the plugin to OpenClaw once.
2. **Connect Google Classroom** — one-click OAuth in the ClawLink dashboard.
3. **Use it from chat** — ask OpenClaw in plain English.

**Alternative for any agent (no plugin needed):** if the OpenClaw plugin route isn't available or doesn't work, any AI agent with shell access can use the ClawLink CLI instead:

```bash
npx -y @useclawlink/cli login          # sign in via browser — no API key to paste
npx -y @useclawlink/cli connect google-classroom  # connect Google Classroom (browser OAuth)
npx -y @useclawlink/cli actions google-classroom  # list available actions
npx -y @useclawlink/cli run google-classroom <action> --input '<json>'  # execute (add --confirm for writes)
```

### Install by command

The setup prompt above does all of this in one paste. By hand, it is one install command plus a browser approval:

```bash
openclaw plugins install clawhub:clawlink-plugin
```

Then ask OpenClaw to set up ClawLink. It starts browser pairing and prints an approval link — open it, approve the device, return to the chat, and say `done`. Finally, connect Google Classroom in the [ClawLink dashboard](https://claw-link.dev/dashboard) — a one-click OAuth approval, no API keys.

Verify the connection by asking OpenClaw:

> List my courses with google_classroom_courses_list, then pull coursework for each with google_classroom_course_work_list. Show me everything due in the next week, grouped by course.

### Using a different agent?

The OpenClaw plugin is one client of ClawLink's MCP server. Claude Code, Cursor, Codex, or any agent that can run a shell command pairs with the same ClawLink account through the CLI:

```bash
npx -y @useclawlink/cli login
```

`login` opens the same browser approval and stores a credential locally. Once Google Classroom is connected in the dashboard, that agent calls the same 62 Google Classroom tools over MCP. Full setup for MCP clients and shell agents: [connect apps to any AI agent](https://claw-link.dev/learn/connect-apps-to-any-ai-agent).

## Google Classroom MCP for OpenClaw

Looking for a Google Classroom MCP server for OpenClaw? ClawLink connects Google Classroom to OpenClaw and exposes 62 Google Classroom tools your agent can call over [MCP](https://claw-link.dev/learn/what-is-an-mcp-server), with [hosted auth](https://claw-link.dev/learn/oauth-for-ai-agents) and nothing to run or maintain yourself. Using Hermes instead? The [Hermes Google Classroom integration](https://claw-link.dev/hermes/google-classroom) works the same way.

OpenClaw has no built-in Google Classroom integration, which is why the answers you will find teach a Google Cloud project with a service account, or a Composio CLI walkthrough with an MCP config file. This is the shorter route: install the ClawLink skill, connect Google Classroom in the dashboard with one browser sign-in, and OpenClaw can call the 62 Classroom tools below from the next message. It is hosted OAuth — one click, no API keys, no Cloud Console, and nothing in a config file. Worth saying plainly because the open-source Classroom servers set the opposite expectation: this toolset is not read-only, and it can create coursework, post materials, and read submissions as far as your Classroom role allows.

## What the OpenClaw Google Classroom integration can do

62 Google Classroom tools are ready for OpenClaw once the account is connected. The 30 below are the ones people reach for most; your agent can call all 62.

### 30 of 62 Google Classroom tools for OpenClaw

| Tool | What it does |
|---|---|
| **Course work create** `google_classroom_course_work_create` | Tool to create a CourseWork item in a course. Use when you need to assign an assignment or question to students immediately or on a schedule. |
| **Course work get** `google_classroom_course_work_get` | Tool to get details of a specific coursework. Use when detailed information about a particular assignment is needed. |
| **Course work list** `google_classroom_course_work_list` | Tool to list coursework in a course. Use after verifying courseId. |
| **Course work materials create** `google_classroom_course_work_materials_create` | Tool to create course work material. Use when adding resources or notes to a course. |
| **Course work materials get** `google_classroom_course_work_materials_get` | Tool to get a coursework material. Use when you need to retrieve details of a specific coursework material by course and material ID. |
| **Course work materials list** `google_classroom_course_work_materials_list` | Tool to list course work materials in a course. Use when you need to retrieve and paginate materials for a given courseId. |
| **Course work student submissions list** `google_classroom_course_work_student_submissions_list` | Tool to list student submissions for a specific coursework. Use when you need to fetch or paginate student submissions by course and coursework, optionally filtering by user, state, or timeliness. |
| **Course work student submissions reclaim** `google_classroom_course_work_student_submissions_reclaim` | Tool to reclaim a student submission for editing. Use after a student requests to edit their turned-in submission, resetting its state to CREATED. |
| **Courses aliases create** `google_classroom_courses_aliases_create` | Tool to create an alias for a course. Use when you need to add an alternative identifier to a course after confirming the course ID. |
| **Courses aliases list** `google_classroom_courses_aliases_list` | Tool to list aliases for a course. Use when you need to retrieve all aliases associated with a specific course. |
| **Courses announcements get** `google_classroom_courses_announcements_get` | Get an announcement |
| **Courses announcements get add on context** `google_classroom_courses_announcements_get_add_on_context` | Get metadata for Classroom add-ons in the context of a specific announcement post |
| **Courses announcements list** `google_classroom_courses_announcements_list` | List announcements in a course |
| **Courses announces add on attachs get** `google_classroom_courses_announces_add_on_attachs_get` | Get an add-on attachment from an announcement |
| **Courses announces add on attachs list** `google_classroom_courses_announces_add_on_attachs_list` | List all add-on attachments created under an announcement |
| **Courses course work get add on context** `google_classroom_courses_course_work_get_add_on_context` | Get metadata for Classroom add-ons in the context of a specific course work |
| **Courses course work materials add attachs** `google_classroom_courses_course_work_materials_add_attachs` | List all add-on attachments under a course work material post |
| **Courses coursework rubrics list** `google_classroom_courses_coursework_rubrics_list` | List rubrics for a specific coursework |
| **Courses get** `google_classroom_courses_get` | Get details for a specific course |
| **Courses get grading period settings** `google_classroom_courses_get_grading_period_settings` | Retrieve grading period settings for a course |
| **Courses list** `google_classroom_courses_list` | List all courses accessible to the authenticated user |
| **Courses posts add on attachments list** `google_classroom_courses_posts_add_on_attachments_list` | List all add-on attachments created under a post |
| **Courses posts get add on context** `google_classroom_courses_posts_get_add_on_context` | Get metadata for Classroom add-ons in the context of a specific post |
| **Courses students get** `google_classroom_courses_students_get` | Retrieve a specific student of a course |
| **Courses students guardians list** `google_classroom_courses_students_guardians_list` | List guardians of a student in a course |
| **Courses students list** `google_classroom_courses_students_list` | List students in a course |
| **Courses teachers get** `google_classroom_courses_teachers_get` | Get teacher enrollment |
| **Courses teachers list** `google_classroom_courses_teachers_list` | List teachers in a course |
| **Courses topics get** `google_classroom_courses_topics_get` | Get a course topic |
| **Courses topics list** `google_classroom_courses_topics_list` | List topics in a course |

## Example prompts

**See what is outstanding**

> List my courses with google_classroom_courses_list, then pull coursework for each with google_classroom_course_work_list. Show me everything due in the next week, grouped by course.

**Create an assignment**

> In the course "\<course>", create coursework titled "\<title>" with google_classroom_course_work_create, description from the notes above, due \<date>. Show me the payload before creating it.

**Check who has submitted**

> For the coursework "\<title>" in "\<course>", use google_classroom_course_work_student_submissions_list to tell me who has turned it in and who has not. Do not change any submission states.

**Post materials**

> Add the reading list above to "\<course>" as course materials with google_classroom_course_work_materials_create, titled "\<title>". Show it to me first — students see it immediately.

## How the Google Classroom tools behave

Classroom's own rules explain nearly every surprising result here.

- **Your role on each course is the real permission boundary.** The same connection can read one course fully and none of another. `google_classroom_courses_list` is the first diagnostic for anything permission-shaped.
- **Submissions are addressed per coursework item.** `google_classroom_course_work_student_submissions_list` needs both the course id and the coursework id, so listing coursework comes first.
- **Coursework and materials are different objects.** `google_classroom_course_work_create` posts assignments students can submit to; `google_classroom_course_work_materials_create` posts reference material with no submission attached.
- **Courses can be addressed by alias as well as id.** `google_classroom_courses_aliases_list` and `..._create` manage those, which matters when integrating with a school information system that has its own identifiers.
- **Writes are visible to students immediately.** Announcements, coursework, and materials appear in the course as soon as they are created — review before posting, not after.
- **Guardian data is reachable and sensitive.** `google_classroom_courses_students_guardians_list` returns guardian contacts; treat it as the most restricted thing in the toolset.

## ClawLink vs. building it yourself

The alternative to ClawLink is usually manual OAuth app setup plus your own token handling, permission troubleshooting, and tool plumbing for OpenClaw. That is fine if you want to build and maintain the integration yourself. Most teams just want Google Classroom working from chat.

| | Manual | ClawLink |
|---|---|---|
| **Connection flow** | Register a Google Classroom app, configure redirect URLs, manage consent details, and reconnect users when auth settings drift. | Users connect Google Classroom through the hosted browser flow and ClawLink keeps the token lifecycle out of your app code. |
| **Ongoing maintenance** | You own refresh logic, permission debugging, environment config, and every provider-specific edge case for Google Classroom. | ClawLink handles the repetitive integration plumbing so your team can focus on the workflow instead of the infrastructure. |
| **Agent usability** | You still need to expose the right Google Classroom actions to the runtime in a format your agent can reliably use. | 62 tools for Google Classroom are already exposed through ClawLink, so the agent can read and act from chat immediately. |

## ClawLink vs. Composio

Composio also exposes Google Classroom to AI agents. It is developer infrastructure: Python and TypeScript SDKs, an MCP server, and a catalog past 1,000 apps, aimed at teams shipping agent products. ClawLink is built for OpenClaw users instead. You install the plugin once, connect Google Classroom in the browser, and the 62 tools above work from chat. There is no SDK, no config file, and no API key handling. Choosing between them? Read the full [Composio alternatives](https://claw-link.dev/hub/composio-alternatives) comparison.

### OpenClaw installed the Google Classroom skill but can't call the tools
The ClawHub skill teaches OpenClaw about Google Classroom, but the calls run through the ClawLink plugin and your connected account. Make sure Google Classroom is connected in the dashboard, then start a fresh chat so OpenClaw reloads the tool catalog. If OpenClaw runs as a persistent gateway, restart it so the new tools register.

### Connection succeeds but no tools appear
Reconnect Google Classroom from the dashboard, then start a fresh chat if the runtime still has the old tool catalog loaded.

### "Tool schema not loaded yet" error when calling Google Classroom tools
Google Classroom tool schemas load on demand the first time a tool runs and are cached after that, so this error usually clears on its own: wait a few seconds and retry the same request. If every Google Classroom call keeps failing with it in a fresh chat, reconnect from the dashboard, and contact support if it still persists — that pattern points to a configuration problem on our side, not something you can fix by reconnecting again.

### Google Classroom returns 403 or "permission denied" on one action while others work
Two usual causes. The connected account may not have access to the specific workspace, inbox, store, or project in the request — check that first. If access looks right, the agent may have sent a placeholder value (like "YOUR_ID" or an example id from documentation) instead of a real one: ask it to run a list or search tool first, then retry the action with a real id from those results. Most failures at this stage are one of these two, not ClawLink bugs.

### Google Classroom returns 403 or "The caller does not have permission" on one course
Classroom's permission model is per-course and role-based, and that is almost always the cause. The connected account must hold the right role on that specific course for the action attempted — reading a roster or student submissions requires being a teacher on it — so an account that teaches some courses and not others succeeds and fails in exactly this pattern. That is Classroom enforcing course boundaries, not a scope problem, and no reconnection changes it. Two other causes are worth ruling out: on a managed Workspace domain an admin policy can block third-party app authorization entirely, which shows up at connect time rather than per course; and a course id copied from documentation fails as a permission error rather than a not-found. Note that the fix search results suggest most often — delete the cached token file and re-authenticate — has no equivalent here, because there is no token file on your machine.

Ask the agent to diagnose it:

```text
Run google_classroom_courses_list and tell me which courses this connection can see and what role the account holds on each. Do not retry the failed call yet.
```

### "Course not found" for a course you can open in Classroom yourself
Usually the account, sometimes the identifier. Teachers and students routinely hold both a personal Google account and a school one, and the courses the agent sees belong to whichever account approved the connection — connect with the wrong one and it looks perfectly healthy while finding nothing. The identifier cause is that courses can be addressed by id or by an alias, and an alias that was never created does not resolve. Have the agent run google_classroom_courses_list first and work from the ids it returns; google_classroom_courses_aliases_list shows which aliases exist if you depend on them.

Ask the agent to diagnose it:

```text
Tell me which Google account this connection is acting as, then run google_classroom_courses_list and show me every course with its id and your role on it.
```

### Student submissions come back empty for coursework that clearly has them
Two boundaries produce an empty list rather than an error. The first is role: only a teacher on that course can list other people's submissions, so a student account sees only its own and a connection made with the wrong account returns nothing without complaining. The second is the shape of the query — google_classroom_course_work_student_submissions_list works per coursework item, so it needs the course id and the coursework id, and an agent holding only the course id cannot find submissions by guessing. Ask it to list coursework with google_classroom_course_work_list first, then pull submissions for the specific item.

Ask the agent to diagnose it:

```text
Run google_classroom_course_work_list for the course and show me each item with its id. Then list submissions for the one I name, and tell me what role you hold on that course.
```

### OAuth finished in the browser but the account is still missing
Try reconnecting Google Classroom and complete the consent flow in the same browser session. Partial OAuth approvals or switching accounts mid-flow can leave the connection incomplete.

### Is there a OpenClaw Google Classroom integration?
Yes. ClawLink is the fastest way to connect OpenClaw to Google Classroom: link your Google Classroom account once in the browser and OpenClaw can call the Google Classroom API through 62 ready-made tools — no custom code or token handling.

### How do I add Google Classroom to OpenClaw with ClawLink?
Paste the setup prompt from this page into OpenClaw. It installs the ClawLink Google Classroom skill from ClawHub, then you click Connect in the dashboard to authorize Google Classroom. OpenClaw calls the tools from the next message — no config files or API keys to manage.

### How long does it take to connect Google Classroom to OpenClaw?
About two minutes. Sign in, click Connect next to Google Classroom in the dashboard, authenticate, and OpenClaw can use it from the next chat message.

### Why use ClawLink instead of wiring Google Classroom up myself?
The alternative to ClawLink is usually manual OAuth app setup plus your own token handling, permission troubleshooting, and tool plumbing for OpenClaw. That is fine if you want to build and maintain the integration yourself. Most teams just want Google Classroom working from chat.

### Does OpenClaw have a Google Classroom integration?
Not built in — which is why searching usually returns the answer that no integration exists, followed by manual instructions. OpenClaw ships without Classroom tools, so they have to come from somewhere, and the common suggestions are a self-hosted MCP server backed by your own Google Cloud project, or a service account with domain-wide delegation arranged by a Workspace admin. Connecting through ClawLink is the one-click version: approve Classroom on Google's consent screen and the tools are available in the next message, with no Cloud project and no config file.

### What can the agent do — is it read-only?
No, and the open-source options are why people expect otherwise. Several community Classroom servers are read-only by design, so summaries of this space describe agent access as reading courses and rosters. This toolset covers creating and reading coursework, posting course materials and announcements, listing and reclaiming student submissions, managing topics and aliases, reading student and teacher rosters, listing guardians, and reading rubrics and grading-period settings. What it can do in your Classroom is then bounded by your role rather than by the tool list.

### Do I need to be a teacher, and does my admin need to approve it?
Your Classroom role decides what the agent can do, because it acts as you. A teacher on a course can create coursework and read submissions for it; a student sees their own work; an account with no role on a course sees nothing, which is Classroom working correctly rather than a broken connection. Separately, some Workspace domains restrict which third-party apps users may authorize at all, so on a managed school or district account an admin may need to allow the connection before the consent screen completes. That is a Workspace policy question, not something configurable in ClawLink.

### Is it safe to connect Google Classroom to an AI agent?
The connection uses Google's OAuth consent flow, so you approve it on Google's screen, no password is handled, and disconnecting from the dashboard ends access. Classroom deserves more care than most integrations for a non-technical reason: the data includes student names, submissions, and guardian contacts. The sensible defaults are to connect the account whose role you intend the agent to have, keep a human in the loop before anything is posted to a course, and be deliberate about asking an agent to summarize or move student work at all. Whatever student-data rules apply to your institution apply to the agent's use of that data too.

### OpenClaw installed the Google Classroom skill but can't call the tools
The ClawHub skill teaches OpenClaw about Google Classroom, but the calls run through the ClawLink plugin and your connected account. Make sure Google Classroom is connected in the dashboard, then start a fresh chat so OpenClaw reloads the tool catalog. If OpenClaw runs as a persistent gateway, restart it so the new tools register.

## Related

- [OpenClaw Google Super integration](https://claw-link.dev/openclaw/google-super) — Unified access to multiple Google services in one integration
- [OpenClaw Google Drive integration](https://claw-link.dev/openclaw/google-drive) — Upload, search, and manage files
- [Google Analytics](https://claw-link.dev/openclaw/google-analytics) — Connect Google Analytics properties through hosted Google OAuth