Mentortools Make integrationAutomate Mentortools with Make.

Count Courses gives you a single figure: how many courses Mentortools reports at the moment the module runs. Handy when a report only needs the total and not the list of courses behind it.

Need to know how many lessons exist before an audit or a content review? This module answers with one number and nothing else, which keeps the rest of the scenario light.

In Mentortools, a module is a chapter of a course, and Count Modules tells you how many of those chapters exist. You get the total in one bundle, ready to drop into a message or a sheet.

Submodules are the sections one level below a course module, and this action returns how many of them Mentortools holds. It is the quickest check on the deepest part of your course structure.

Create a Course opens a new course in Mentortools from data another app sends. In most build scenarios it is the first Mentortools step, the one every later chapter and lesson hangs from.

This action adds a lesson inside a course module, so the content students open shows up in the chapter where it belongs. It saves the copy and paste of every lesson from your drafting tool.

With Create a Module, a course gets a new chapter, the container that later holds lessons and submodules. Chained after Create a Course, it turns one outline into a structured course in a single run.

When a chapter grows too long, Create a Submodule nests a smaller section under it and keeps the course navigation readable for students.

Delete a Course removes a course from Mentortools, and the doc states that all of its data goes with it. Use it for deliberate clean-up, never as a casual step in a busy scenario.

One lesson out, the rest of the chapter untouched: this action erases a single lesson and, according to the doc, all the data attached to it.

A whole chapter leaves the course with Delete a Module, and the doc says its data is deleted along with it. That makes it the heaviest delete among the course modules after Delete a Course.

Removes one submodule from its chapter, including the data stored in that section, which is the smallest cut you can make in a course structure.

Reading a single course is what Get a Course does: it returns that course's details as one bundle the next modules can reuse.

With Get a Lesson, a scenario reads the details of one lesson in a module and passes them down the chain, for example to another app that stores your course material.

This action reads one course module and returns its details, so later steps can reuse what Mentortools knows about that chapter.

Get a Submodule pulls the details of one section inside a chapter and hands them to the next module as a single bundle.

Mentortools offers a second way to read a course: Get Course Info returns what the doc calls the detailed information of a course, next to the plain read of Get a Course.

For lessons too, a detailed read exists: Get Lesson Info returns the extended information of one lesson rather than its basic details.

A chapter seen in full: Get Module Info gives the detailed view of a course module when a plain read with Get a Module feels too thin.

Make an API Call is the way out when the listed modules stop short: it calls any endpoint of the Mentortools API, reusing the connection you already set up.

Changes the details of a course that already exists, so you never rebuild a course just to fix what describes it.

Update a Lesson edits an existing lesson in place instead of deleting it and creating a new one, which keeps your course tidy.

Reworking a chapter? Update a Module applies new details to an existing course module, without creating a second chapter next to the old one.

This module updates the details of one existing submodule, the section level that sits under a course module.

List Courses brings back all your courses, one bundle per course, so the next modules can act on each of them in turn.

Returns all lessons as separate bundles, which turns a single run into one pass per lesson for every module that follows.

Every chapter of your courses, laid out as separate bundles: that is what List Modules hands to the rest of the scenario.

Scoped to one course module, List Submodules returns each of its sections as its own bundle.

Create a Folder adds a folder in Mentortools. The doc gives it no description, so the module name is the only official hint about what it does.

Create an Order is the only order module of the app, and the Make doc says nothing more about it than its name.

Delete a File removes one file stored in Mentortools. No official description comes with it, so treat the name as the whole contract.

Getting rid of a folder you no longer need is what this module is named for; the doc adds no further detail about its behavior.

To read one file's details inside a scenario, add Get a File and point it at the file you want; the result comes back as a single bundle.

Get a Folder reads one folder so later steps can reuse its details, for example to decide where a new file should go.

One bundle per file: List All Files returns the files stored in Mentortools, ready to be handled one by one by the modules that follow.

Returns your Mentortools folders as separate bundles, a quick way to see how course material is organized without opening the app.

Update a File changes a file that already sits in Mentortools, rather than uploading a second copy next to the old one.

This module applies changes to a folder that already exists in Mentortools; beyond its name, the doc gives no description.

Upload a File sends a file from another app into Mentortools, such as a handout produced earlier in the scenario or stored in a shared drive.