Turn Moodle Pages into NotebookLM Markdown with a Local Chrome Extension

Moodle content is rarely in one convenient document. A course can spread its material across lessons, pages, files, and embedded videos. Copying each page into a notebook by hand is slow, and a generic scraper can lose the course and module boundaries that make the material useful later.

This tutorial shows a local workflow using Moodle Content Extractor for NotebookLM. You will load the open-source Manifest V3 extension, enable capture for a Moodle site, browse the pages you want, and export one Markdown file with course and module structure preserved.

The project is a browser extension, not a hosted crawler. It processes captured content in the browser and creates files only when you request an export. That boundary matters when course pages contain private or copyrighted material.

What you will build

The workflow looks like this:

1. Install the extension from the Chrome Web Store, or load the source as an unpacked extension.
2. Configure the base URL of your Moodle installation.
3. Start capture through the extension popup.
4. Browse the lesson and activity pages you want to study.
5. Stop capture and export the course as Markdown.
6. Upload that Markdown file to NotebookLM yourself if you want a source-grounded study notebook.

The repository's current stable release is v1.4.0. The release notes describe a fix for same-tab Moodle navigation, protection for corrupt or empty module records, and URL normalization for lesson modules.

Prerequisites

You need:

• Chrome, Edge, or another Chromium-based browser that supports Manifest V3 extensions.
• Access to a Moodle site that you are allowed to read and export.
• A local copy of the extension only if you choose the unpacked installation.
• NotebookLM as an optional destination. The extension does not call NotebookLM or require a NotebookLM account.

The release package has no dependency installation step and no build step. If you load from source, use the v1.4.0 tag so the files you test match the stable release.

Install from source

The Web Store is the shortest path. For a source-based installation, clone the stable tag:

git clone --branch v1.4.0 --depth 1 https://github.com/paladini/extract-moodle-content-to-notebook-lm-extension.git
cd extract-moodle-content-to-notebook-lm-extension

Open chrome://extensions in Chromium. Turn on Developer mode, choose Load unpacked, and select the cloned directory. The project is a zero-dependency extension, so there is no npm install or build command to run.

The manifest declares Manifest V3, a background service worker, a popup, and permissions for activeTab, scripting, storage, and downloads. It also declares *://*/* host access so capture can continue across page navigations after you enable it.

Capture a Moodle course

Click the extension icon and save your Moodle base URL. A value such as https://moodle.example.edu is a placeholder. Use the origin and path that actually identify your installation, without inventing a URL for a site you do not control.

Click Start Capture, then browse the Moodle lesson or activity pages you want to include. The extension groups pages using Moodle breadcrumbs and page context. When you are finished, click Stop Capture. You can then export one course or export all captured courses.

The important operational detail is explicit capture mode. The extension does not treat every page you visit as course content. Its content script checks the configured Moodle base URL and exits on pages that do not match it. This is documented in the project's permission justification.

An export is structured Markdown rather than a flat text dump. A simplified example looks like this:

# Course Name

## Module: 1.1 Introduction to Databases
Type: lesson
Captured at: 2026-03-11T02:30:00.000Z

[extracted content]

### Videos
- https://youtube.com/example

### Resources
- https://moodle.example.edu/pluginfile.php/example.pdf

The timestamp and URLs are useful for checking where a passage came from and for keeping exports and backups consistent. The actual export includes the captured page content and any detected video or attachment links that the extractor supports.

Why the local design is useful

The extension stores course data in Chrome extension storage. The background service worker handles persistence, while the content script extracts content from a matching Moodle page. The popup provides capture controls, course management, export actions, and backup or restore actions.

This division keeps the workflow understandable:

• content.js reads the page and extracts course material.
• background.js groups and stores records in chrome.storage.local.
• popup.js starts and stops capture and turns stored records into downloads.

Chrome's Storage API documentation describes storage.local as extension-local storage. Chrome documents a default local-storage limit of 10 MB, so a very large course export may need to be split or managed carefully. The extension's local backup and recovery features reduce the chance that a failed write silently destroys the only copy in the browser, but they do not replace an external backup of exported files.

The downloads permission is used for explicit Markdown and JSON export actions. Chrome's downloads API reference confirms that this permission is required to initiate downloads. The extension does not need a remote server for normal use, and its privacy policy says data leaves the browser when you explicitly export, import a backup, or upload an exported file to another product.

Verify the installation before capturing real content

You can perform a low-risk source check before granting access to a Moodle site. Confirm that the manifest reports version 1.4.0, that the background service worker is background.js, and that the referenced popup and icon files exist in the directory.

On a machine with Node.js, the JavaScript files can also be parsed without executing them:

node --check background.js
node --check content.js
node --check popup.js

The commands check syntax only. They do not prove that a particular Moodle theme, login flow, embedded video, or attachment format will extract correctly. For a functional check, use a course page you are permitted to process, capture one lesson, export it, and inspect the resulting Markdown before uploading it anywhere.

Your verification checklist should be concrete:

• The course name and module headings are present.
• The captured text matches the page you selected.
• Video and resource links point to the expected locations.
• A page outside the configured Moodle base URL was not added as course content.
• The exported file opens as ordinary Markdown and does not contain unexpected credentials or private browser data.

Failure modes and limits

If a newly visited lesson is missing, confirm that capture mode is still enabled and that the page matches the configured base URL. Same-tab navigation was specifically addressed in the v1.4.0 release, but a Moodle installation can still use custom page structures that the extractor does not recognize.

If an export is incomplete, inspect the source page and the extension's supported extraction behavior. Embedded content can require its own permissions or may not expose readable text in the page DOM. A linked PDF or presentation is represented as a resource link; the extension does not claim to convert every attachment into Markdown.

If storage writes fail, reduce the amount captured in one browser storage set and export more frequently. Chrome's storage quota is a real limit, not a promise that an arbitrarily large course can stay in one local record.

Most importantly, local processing is not the same as unrestricted use. Moodle content may contain student information, licensed textbooks, assessments, or internal course material. Capture only what you are authorized to access, keep exported files private, and review the destination's data-handling terms before uploading them. The extension's privacy policy documents its intended local-first behavior, but it cannot control what happens after you export a file.

FAQ

Does this require an API key?

No. The documented workflow uses the browser extension and local browser storage. NotebookLM is an optional destination, not an API dependency.

Does it crawl Moodle in the background?

No. You enable capture through the popup and browse the pages yourself. The extension injects its capture logic for matching pages while capture mode is active.

Can it export every file attached to a course?

It extracts links to supported resources such as PDF, DOCX, and PPTX. Those links are included in the Markdown; the project does not claim to transform every attachment into text.

Is the current branch identical to the release?

Not necessarily. This tutorial targets the stable v1.4.0 tag. If you use the default branch, inspect its manifest and documentation again because unreleased changes can alter behavior.

Takeaway

A useful NotebookLM source starts before the AI notebook: it starts with a clean, traceable input. This extension turns a user-selected Moodle browsing session into course and module-aware Markdown while keeping capture and export actions visible.

The practical next step is to test one permitted lesson, inspect the Markdown, and only then decide whether the local export is complete enough for your study workflow.

What Moodle structure causes the most trouble in your own courses: breadcrumb grouping, embedded media, or attached documents?

AI assistance disclosure

AI assistance was used to help organize and edit this tutorial. The repository documentation, stable release metadata, Chrome API documentation, source checkout, and syntax checks were reviewed before publication. Claims about the project are limited to those sources and the documented workflow.