Teachable MCP Server &amp; CLI

Add it with a single command in a terminal.

Put your own API key in place of the example.

claude mcp add teachable \
  -e TEACHABLE_API_KEY=YOUR_API_KEY \
  -- npx -y @thenavidm/teachable-mcp-cli@latest

2
In Claude Code, type /mcp. Teachable should show as connected.
```
/mcp
```

Add it with a single command in a terminal.

Put your own API key in place of the example.

claude mcp add teachable -e TEACHABLE_API_KEY="YOUR_API_KEY" -- npx -y @thenavidm/teachable-mcp-cli@latest

2
In Claude Code, type /mcp. Teachable should show as connected.
```
/mcp
```

Add it with a single command in a terminal.

Put your own API key in place of the example.

claude mcp add teachable \
  -e TEACHABLE_API_KEY=YOUR_API_KEY \
  -- npx -y @thenavidm/teachable-mcp-cli@latest

2
In Claude Code, type /mcp. Teachable should show as connected.
```
/mcp
```

Your computer

Add it with a single command in a terminal.

Put your own API key in place of the example.

codex mcp add teachable \
  --env TEACHABLE_API_KEY=YOUR_API_KEY \
  -- npx -y @thenavidm/teachable-mcp-cli@latest

2
Check that Codex lists it.
```
codex mcp list
```

Add it with a single command in a terminal.

Put your own API key in place of the example.

codex mcp add teachable --env TEACHABLE_API_KEY="YOUR_API_KEY" -- npx -y @thenavidm/teachable-mcp-cli@latest

2
Check that Codex lists it.
```
codex mcp list
```

Add it with a single command in a terminal.

Put your own API key in place of the example.

codex mcp add teachable \
  --env TEACHABLE_API_KEY=YOUR_API_KEY \
  -- npx -y @thenavidm/teachable-mcp-cli@latest

2
Check that Codex lists it.
```
codex mcp list
```

1
Open Cursor's settings, go to the MCP tab, and click Add new global MCP server.

Add the server.

Put your own API key in place of the example.

{
  "mcpServers": {
    "teachable": {
      "command": "npx",
      "args": ["-y", "@thenavidm/teachable-mcp-cli@latest"],
      "env": {
        "TEACHABLE_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

3
Open the MCP tab again. It should show 26 tools.

1
Open the Command Palette and run MCP: Open User Configuration.

Add the server to that mcp.json.

If the file already has servers, add only this one inside servers. Put your own API key in place of the example.

{
  "servers": {
    "teachable": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@thenavidm/teachable-mcp-cli@latest"],
      "env": {
        "TEACHABLE_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

Your computer

Add it with a single command in a terminal.

Put your own API key in place of the example.

copilot mcp add teachable \
  --env TEACHABLE_API_KEY=YOUR_API_KEY \
  -- npx -y @thenavidm/teachable-mcp-cli@latest

2
Check that Copilot CLI has it.
```
copilot mcp get teachable
```

Add it with a single command in a terminal.

Put your own API key in place of the example.

copilot mcp add teachable --env TEACHABLE_API_KEY="YOUR_API_KEY" -- npx -y @thenavidm/teachable-mcp-cli@latest

2
Check that Copilot CLI has it.
```
copilot mcp get teachable
```

Add it with a single command in a terminal.

Put your own API key in place of the example.

copilot mcp add teachable \
  --env TEACHABLE_API_KEY=YOUR_API_KEY \
  -- npx -y @thenavidm/teachable-mcp-cli@latest

2
Check that Copilot CLI has it.
```
copilot mcp get teachable
```

Your computer

1
Open your Gemini CLI settings.
```
~/.gemini/settings.json
```

Add the server to settings.json.

If the file already has servers, add only this one inside mcpServers. Put your own API key in place of the example.

{
  "mcpServers": {
    "teachable": {
      "command": "npx",
      "args": ["-y", "@thenavidm/teachable-mcp-cli@latest"],
      "env": {
        "TEACHABLE_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

3
Restart Gemini CLI and type /mcp to check it.
```
/mcp
```

1
Open your Gemini CLI settings.
```
%USERPROFILE%\.gemini\settings.json
```

Add the server to settings.json.

If the file already has servers, add only this one inside mcpServers. Put your own API key in place of the example.

{
  "mcpServers": {
    "teachable": {
      "command": "npx",
      "args": ["-y", "@thenavidm/teachable-mcp-cli@latest"],
      "env": {
        "TEACHABLE_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

3
Restart Gemini CLI and type /mcp to check it.
```
/mcp
```

1
Open your Gemini CLI settings.
```
~/.gemini/settings.json
```

Add the server to settings.json.

If the file already has servers, add only this one inside mcpServers. Put your own API key in place of the example.

{
  "mcpServers": {
    "teachable": {
      "command": "npx",
      "args": ["-y", "@thenavidm/teachable-mcp-cli@latest"],
      "env": {
        "TEACHABLE_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

3
Restart Gemini CLI and type /mcp to check it.
```
/mcp
```

Your computer

1
Open your OpenCode config.
```
~/.config/opencode/opencode.json
```

Add the server under mcp.

If the file already has servers, add only this one inside mcp. Put your own API key in place of the example.

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "teachable": {
      "type": "local",
      "command": ["npx", "-y", "@thenavidm/teachable-mcp-cli@latest"],
      "enabled": true,
      "environment": {
        "TEACHABLE_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

3
Restart OpenCode.

Open your OpenCode config.

%USERPROFILE%\.config\opencode\opencode.json

Add the server under mcp.

If the file already has servers, add only this one inside mcp. Put your own API key in place of the example.

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "teachable": {
      "type": "local",
      "command": ["npx", "-y", "@thenavidm/teachable-mcp-cli@latest"],
      "enabled": true,
      "environment": {
        "TEACHABLE_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

3
Restart OpenCode.

1
Open your OpenCode config.
```
~/.config/opencode/opencode.json
```

Add the server under mcp.

If the file already has servers, add only this one inside mcp. Put your own API key in place of the example.

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "teachable": {
      "type": "local",
      "command": ["npx", "-y", "@thenavidm/teachable-mcp-cli@latest"],
      "enabled": true,
      "environment": {
        "TEACHABLE_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

3
Restart OpenCode.

Your computer

Add it with a single command in a terminal.

Put your own API key in place of the example.

openclaw mcp add teachable \
  --command npx \
  --arg -y \
  --arg @thenavidm/teachable-mcp-cli@latest \
  --env TEACHABLE_API_KEY=YOUR_API_KEY

2
Check that it starts and lists its tools.
```
openclaw mcp doctor teachable --probe
```

Add it with a single command in a terminal.

Put your own API key in place of the example.

openclaw mcp add teachable --command npx --arg -y --arg @thenavidm/teachable-mcp-cli@latest --env TEACHABLE_API_KEY="YOUR_API_KEY"

2
Check that it starts and lists its tools.
```
openclaw mcp doctor teachable --probe
```

Add it with a single command in a terminal.

Put your own API key in place of the example.

openclaw mcp add teachable \
  --command npx \
  --arg -y \
  --arg @thenavidm/teachable-mcp-cli@latest \
  --env TEACHABLE_API_KEY=YOUR_API_KEY

2
Check that it starts and lists its tools.
```
openclaw mcp doctor teachable --probe
```

1
In the agent panel, click the … menu, then MCP Servers, Manage MCP Servers and View raw config.

Add the server to mcp_config.json.

If the file already has servers, add only this one inside mcpServers. Put your own API key in place of the example.

{
  "mcpServers": {
    "teachable": {
      "command": "npx",
      "args": ["-y", "@thenavidm/teachable-mcp-cli@latest"],
      "env": {
        "TEACHABLE_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

Your computer

1
Open your Hermes config.
```
~/.hermes/config.yaml
```

Add the server under mcp_servers.

If the file already has mcp_servers, add only this one under it. Put your own API key in place of the example.

mcp_servers:
  teachable:
    command: "npx"
    args: ["-y", "@thenavidm/teachable-mcp-cli@latest"]
    env:
      TEACHABLE_API_KEY: "YOUR_API_KEY"

1
Open your Hermes config.
```
%USERPROFILE%\.hermes\config.yaml
```

Add the server under mcp_servers.

If the file already has mcp_servers, add only this one under it. Put your own API key in place of the example.

mcp_servers:
  teachable:
    command: "npx"
    args: ["-y", "@thenavidm/teachable-mcp-cli@latest"]
    env:
      TEACHABLE_API_KEY: "YOUR_API_KEY"

1
Open your Hermes config.
```
~/.hermes/config.yaml
```

Add the server under mcp_servers.

If the file already has mcp_servers, add only this one under it. Put your own API key in place of the example.

mcp_servers:
  teachable:
    command: "npx"
    args: ["-y", "@thenavidm/teachable-mcp-cli@latest"]
    env:
      TEACHABLE_API_KEY: "YOUR_API_KEY"

Your computer

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Give Claude Code the skill, so it knows every command.
The skill is the SKILL.md in the package. It tells Claude Code what each command does and which ones ask first.
```
mkdir -p ~/.claude/skills/teachable
cp "$(npm root -g)/@thenavidm/teachable-mcp-cli/SKILL.md" ~/.claude/skills/teachable/
```
3
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.zshrc
```
4
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
5
Ask Claude Code to use teachable-cli.
Running teachable-cli on its own lists every command, so Claude Code finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

Give Claude Code the skill, so it knows every command.

The skill is the SKILL.md in the package. It tells Claude Code what each command does and which ones ask first.

New-Item -ItemType Directory -Force "$HOME\.claude\skills\teachable" | Out-Null
Copy-Item "$(npm root -g)\@thenavidm\teachable-mcp-cli\SKILL.md" "$HOME\.claude\skills\teachable\"

3
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
setx TEACHABLE_API_KEY "YOUR_API_KEY"
```
4
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
5
Ask Claude Code to use teachable-cli.
Running teachable-cli on its own lists every command, so Claude Code finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Give Claude Code the skill, so it knows every command.
The skill is the SKILL.md in the package. It tells Claude Code what each command does and which ones ask first.
```
mkdir -p ~/.claude/skills/teachable
cp "$(npm root -g)/@thenavidm/teachable-mcp-cli/SKILL.md" ~/.claude/skills/teachable/
```
3
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.bashrc
```
4
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
5
Ask Claude Code to use teachable-cli.
Running teachable-cli on its own lists every command, so Claude Code finds the one it needs.

Your computer

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Give Codex the skill, so it knows every command.
The skill is the SKILL.md in the package. It tells Codex what each command does and which ones ask first.
```
mkdir -p ~/.agents/skills/teachable
cp "$(npm root -g)/@thenavidm/teachable-mcp-cli/SKILL.md" ~/.agents/skills/teachable/
```
3
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.zshrc
```
4
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
5
Ask Codex to use teachable-cli.
Running teachable-cli on its own lists every command, so Codex finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

Give Codex the skill, so it knows every command.

The skill is the SKILL.md in the package. It tells Codex what each command does and which ones ask first.

New-Item -ItemType Directory -Force "$HOME\.agents\skills\teachable" | Out-Null
Copy-Item "$(npm root -g)\@thenavidm\teachable-mcp-cli\SKILL.md" "$HOME\.agents\skills\teachable\"

3
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
setx TEACHABLE_API_KEY "YOUR_API_KEY"
```
4
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
5
Ask Codex to use teachable-cli.
Running teachable-cli on its own lists every command, so Codex finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Give Codex the skill, so it knows every command.
The skill is the SKILL.md in the package. It tells Codex what each command does and which ones ask first.
```
mkdir -p ~/.agents/skills/teachable
cp "$(npm root -g)/@thenavidm/teachable-mcp-cli/SKILL.md" ~/.agents/skills/teachable/
```
3
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.bashrc
```
4
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
5
Ask Codex to use teachable-cli.
Running teachable-cli on its own lists every command, so Codex finds the one it needs.

Your computer

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.zshrc
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
Ask Cursor to use teachable-cli.
Running teachable-cli on its own lists every command, so Cursor finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
setx TEACHABLE_API_KEY "YOUR_API_KEY"
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
Ask Cursor to use teachable-cli.
Running teachable-cli on its own lists every command, so Cursor finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.bashrc
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
Ask Cursor to use teachable-cli.
Running teachable-cli on its own lists every command, so Cursor finds the one it needs.

Your computer

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.zshrc
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
Ask VS Code to use teachable-cli.
Running teachable-cli on its own lists every command, so VS Code finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
setx TEACHABLE_API_KEY "YOUR_API_KEY"
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
Ask VS Code to use teachable-cli.
Running teachable-cli on its own lists every command, so VS Code finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.bashrc
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
Ask VS Code to use teachable-cli.
Running teachable-cli on its own lists every command, so VS Code finds the one it needs.

Your computer

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Give Copilot CLI the skill, so it knows every command.
The skill is the SKILL.md in the package. It tells Copilot CLI what each command does and which ones ask first.
```
mkdir -p ~/.copilot/skills/teachable
cp "$(npm root -g)/@thenavidm/teachable-mcp-cli/SKILL.md" ~/.copilot/skills/teachable/
```
3
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.zshrc
```
4
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
5
Ask Copilot CLI to use teachable-cli.
Running teachable-cli on its own lists every command, so Copilot CLI finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

Give Copilot CLI the skill, so it knows every command.

The skill is the SKILL.md in the package. It tells Copilot CLI what each command does and which ones ask first.

New-Item -ItemType Directory -Force "$HOME\.copilot\skills\teachable" | Out-Null
Copy-Item "$(npm root -g)\@thenavidm\teachable-mcp-cli\SKILL.md" "$HOME\.copilot\skills\teachable\"

3
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
setx TEACHABLE_API_KEY "YOUR_API_KEY"
```
4
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
5
Ask Copilot CLI to use teachable-cli.
Running teachable-cli on its own lists every command, so Copilot CLI finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Give Copilot CLI the skill, so it knows every command.
The skill is the SKILL.md in the package. It tells Copilot CLI what each command does and which ones ask first.
```
mkdir -p ~/.copilot/skills/teachable
cp "$(npm root -g)/@thenavidm/teachable-mcp-cli/SKILL.md" ~/.copilot/skills/teachable/
```
3
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.bashrc
```
4
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
5
Ask Copilot CLI to use teachable-cli.
Running teachable-cli on its own lists every command, so Copilot CLI finds the one it needs.

Your computer

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.zshrc
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
Ask Gemini CLI to use teachable-cli.
Running teachable-cli on its own lists every command, so Gemini CLI finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
setx TEACHABLE_API_KEY "YOUR_API_KEY"
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
Ask Gemini CLI to use teachable-cli.
Running teachable-cli on its own lists every command, so Gemini CLI finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.bashrc
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
Ask Gemini CLI to use teachable-cli.
Running teachable-cli on its own lists every command, so Gemini CLI finds the one it needs.

Your computer

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Give OpenCode the skill, so it knows every command.
The skill is the SKILL.md in the package. It tells OpenCode what each command does and which ones ask first.
```
mkdir -p ~/.config/opencode/skills/teachable
cp "$(npm root -g)/@thenavidm/teachable-mcp-cli/SKILL.md" ~/.config/opencode/skills/teachable/
```
3
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.zshrc
```
4
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
5
Ask OpenCode to use teachable-cli.
Running teachable-cli on its own lists every command, so OpenCode finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

Give OpenCode the skill, so it knows every command.

The skill is the SKILL.md in the package. It tells OpenCode what each command does and which ones ask first.

New-Item -ItemType Directory -Force "$HOME\.config\opencode\skills\teachable" | Out-Null
Copy-Item "$(npm root -g)\@thenavidm\teachable-mcp-cli\SKILL.md" "$HOME\.config\opencode\skills\teachable\"

3
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
setx TEACHABLE_API_KEY "YOUR_API_KEY"
```
4
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
5
Ask OpenCode to use teachable-cli.
Running teachable-cli on its own lists every command, so OpenCode finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Give OpenCode the skill, so it knows every command.
The skill is the SKILL.md in the package. It tells OpenCode what each command does and which ones ask first.
```
mkdir -p ~/.config/opencode/skills/teachable
cp "$(npm root -g)/@thenavidm/teachable-mcp-cli/SKILL.md" ~/.config/opencode/skills/teachable/
```
3
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.bashrc
```
4
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
5
Ask OpenCode to use teachable-cli.
Running teachable-cli on its own lists every command, so OpenCode finds the one it needs.

Your computer

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Give OpenClaw the skill, so it knows every command.
The skill is the SKILL.md in the package. It tells OpenClaw what each command does and which ones ask first.
```
mkdir -p ~/.openclaw/skills/teachable
cp "$(npm root -g)/@thenavidm/teachable-mcp-cli/SKILL.md" ~/.openclaw/skills/teachable/
```
3
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.zshrc
```
4
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
5
Ask OpenClaw to use teachable-cli.
Running teachable-cli on its own lists every command, so OpenClaw finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

Give OpenClaw the skill, so it knows every command.

The skill is the SKILL.md in the package. It tells OpenClaw what each command does and which ones ask first.

New-Item -ItemType Directory -Force "$HOME\.openclaw\skills\teachable" | Out-Null
Copy-Item "$(npm root -g)\@thenavidm\teachable-mcp-cli\SKILL.md" "$HOME\.openclaw\skills\teachable\"

3
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
setx TEACHABLE_API_KEY "YOUR_API_KEY"
```
4
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
5
Ask OpenClaw to use teachable-cli.
Running teachable-cli on its own lists every command, so OpenClaw finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Give OpenClaw the skill, so it knows every command.
The skill is the SKILL.md in the package. It tells OpenClaw what each command does and which ones ask first.
```
mkdir -p ~/.openclaw/skills/teachable
cp "$(npm root -g)/@thenavidm/teachable-mcp-cli/SKILL.md" ~/.openclaw/skills/teachable/
```
3
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.bashrc
```
4
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
5
Ask OpenClaw to use teachable-cli.
Running teachable-cli on its own lists every command, so OpenClaw finds the one it needs.

Your computer

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.zshrc
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
Ask Antigravity to use teachable-cli.
Running teachable-cli on its own lists every command, so Antigravity finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
setx TEACHABLE_API_KEY "YOUR_API_KEY"
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
Ask Antigravity to use teachable-cli.
Running teachable-cli on its own lists every command, so Antigravity finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.bashrc
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
Ask Antigravity to use teachable-cli.
Running teachable-cli on its own lists every command, so Antigravity finds the one it needs.

Your computer

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.zshrc
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
Ask Hermes to use teachable-cli.
Running teachable-cli on its own lists every command, so Hermes finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
setx TEACHABLE_API_KEY "YOUR_API_KEY"
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
Ask Hermes to use teachable-cli.
Running teachable-cli on its own lists every command, so Hermes finds the one it needs.

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.bashrc
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
Ask Hermes to use teachable-cli.
Running teachable-cli on its own lists every command, so Hermes finds the one it needs.

Your computer

Online course idea generator Online course revenue calculator Online course platform comparison Course platform finder

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.zshrc
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
List every command, then try one.
```
teachable-cli
teachable-cli list-courses
```

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
setx TEACHABLE_API_KEY "YOUR_API_KEY"
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
List every command, then try one.
```
teachable-cli
teachable-cli list-courses
```

Install the CLI. It needs Node 22 or newer.

npm install -g @thenavidm/teachable-mcp-cli@latest

2
Save your Teachable details, so every new session has them.
Put your own API key in place of the example.
```
echo 'export TEACHABLE_API_KEY=YOUR_API_KEY' >> ~/.bashrc
```
3
Check your setup.
It names anything that's wrong and the fix.
```
teachable-cli doctor
```
4
List every command, then try one.
```
teachable-cli
teachable-cli list-courses
```

Needs Node 22 or newer and an API key from your school. Get one in a minute.

It's free and open source. If it saves you time, star it on GitHub, so more people find it.

Rate this tool

This free Teachable MCP server and CLI gives your AI real access to your Teachable school: courses, lectures, quizzes, students, enrollments, pricing plans, sales and webhooks. It reads your courses and each student's progress, enrolls and unenrolls students, adds and updates users, and saves your records into private files.

It's one install with two ways in. Claude, Codex, Cursor or any other MCP app calls its 26 tools for you, and the same tools work as a CLI that agents like Claude Code, Codex and OpenCode run, or that you type yourself.

In this guide, I'll show you:

What the Teachable MCP server & CLI is, and what you can ask it
How to install it and check that it works
When to use the MCP server, and when the CLI
Every tool, and how to keep your account safe

Every tool on this page comes from the server itself, and every cost was measured in Claude Code.

key_takeaways.md

TL;DR

Key takeaways

It gives Claude, Codex, Cursor and any other MCP app 26 tools for your Teachable school: courses, lectures, quizzes, students, enrollments, pricing plans, sales and webhooks.

Every change, like enrolling or unenrolling a student, waits for your approval.

A batch of changes is previewed first, and only the batch you approved runs.

The same tools run as a CLI, which costs your AI nothing until it runs.

What is the Teachable MCP server & CLI?

The Teachable MCP server & CLI is a free, open source program that lets AI agents work in your Teachable school for you, in two ways. The MCP server is what an AI app like Claude, Codex or Cursor connects to, through MCP (Model Context Protocol), the open standard AI apps use to call outside tools.

You ask in plain language. Your AI picks the right tool, and the server makes the call to Teachable's own API.

The CLI is the same program as commands. teachable-cli list-courses runs the same code your AI runs when you ask for your courses, whether an agent like Claude Code runs it or you do.

In an AI OS, the layer that connects your AI to your context, your data and your tools, a server like this is how your AI reaches Teachable. I explain how the parts fit together in how to build an AI operating system, and here's how I use AI myself.

What can you ask it?

Once it's set up, you ask the way you'd ask an assistant. These are real prompts it handles:

Try asking
List my courses and show which ones are published.
How far has this student got in my course?
Show this student's enrollments before I change anything.
Enroll these three students in my new course, and show me the batch before it runs.
Show me my latest sales.
Save my course list into a new private file.

The fourth one shows why this is useful. Your AI prepares every enrollment, you check the preview, and only the batch you approved runs.

It works well next to my Kit MCP server and Circle MCP server, so your AI can email your students and run your community in the same chat. Every server I've made is on my MCP servers page.

For the course itself, my free online course idea generator and online course revenue calculator help too. Teachable is my pick for courses with student apps in the best online course platforms. If you're just starting, here's how to create an online course.

How to install the Teachable MCP server

Pick your app in the box at the top of this page. Each one is a single command or a pasted block, and they all run through npx, so there's nothing to install first.

Windsurf, Zed and Cline take the same server, though they don't have a tab in the box yet. Follow the box's Cursor tab, and put its block here instead:

App	Where the block goes
Windsurf	In the Cascade panel, open the Actions menu (…) and choose Open MCP config file, then paste the block.
Cline	Click the MCP Servers icon in the Cline panel, open the Configure tab, click Configure MCP Servers, and paste the block.
Zed	Go to Settings, then AI, then MCP Servers, and choose Add Server, then Add Local Server. Enter the block's command, arguments and variables, and Zed saves them under `context_servers`.

Before you start0/3

You use an AI app that speaks MCP, like Claude Code, Codex or Cursor. Here's how to install Claude Code if you don't have one yet.

You have Node 22 or newer on your computer.

You can sign in to your Teachable school as its owner, to make an API key.

Watch out: Teachable decides which schools can use its API, and its version 2 beta is open only by request. The server never needs your Teachable password.

Set up your Teachable account

You need one API key, made by the school's owner. It takes a minute.

Get your API key0/4

1Sign in to your school as its owner, and open Settings, then API.

2Click Create API Key, name it, and give it only the permissions you need.

3Copy the key and put it into TEACHABLE_API_KEY in the command for your app, in place of the example.

4Run the doctor check below, then restart your app.

You can keep the key in a private file instead. Point TEACHABLE_CREDENTIALS_FILE at a JSON file holding api_key, readable by you alone. Use one or the other, never both.

teachable-cli login prints these steps in your terminal.

Check that it works

Run the doctor with --network. It checks your settings, then reads your course list once to prove the key works, without changing anything.

npx -y @thenavidm/teachable-mcp-cli doctor --network

When every line has a check mark, restart your app and ask it for your courses. A failed read usually means the key was revoked, or it doesn't have the permission for courses.

In Claude Code, /mcp also shows whether the Teachable server is connected. It's one of the Claude Code commands worth knowing.

Use the Teachable CLI

The CLI is the same 26 tools as commands. AI agents that run commands, like Claude Code, Codex and OpenCode, use it on their own, and you can type the same commands in a terminal or a script.

Every tool name becomes a command with dashes, so list_courses runs as teachable-cli list-courses.

npm install -g @thenavidm/teachable-mcp-cli
teachable-cli
teachable-cli list-courses
teachable-cli get-course-progress --course-id 7 --user-id 9
teachable-cli create-enrollment --course-id 7 --user-id 9 --confirm

The bare teachable-cli lists every command, teachable-cli which <words> finds the command for a task, and teachable-cli <command> --help shows what a command takes. Every change, from enrolling a student to saving an export, needs --confirm, the terminal's version of your approval.

teachable-cli install <app> adds the server to Claude Code, Codex, Claude Desktop, Cursor, VS Code or Gemini CLI, in each app's own format.

These are the flags you'll use most:

Flag	What it does
`--json`	Prints JSON
`--compact`	Prints the JSON on one line
`--select a,b.c`	Keeps only those fields, and a dotted path goes deeper
`--agent`	Machine mode: compact JSON, no prompts, and it never confirms anything
`--confirm`	Lets a write that asks first go ahead
`--dry-run`	Shows what a write would do, without doing it

A script can branch on the exit code:

Exit code	What it means
0	It worked
1	Something unexpected went wrong
2	The command was typed wrong, or a write needed `--confirm`
3	It wasn't found
4	Teachable rejected the credentials
5	Teachable failed or couldn't be reached
7	You hit a rate limit, so wait and try again
10	Nothing is set up yet

MCP server or CLI: which one?

Both are the same program with the same 26 tools. The difference is when your AI pays for them, in the tokens it reads.

Every message, in an app that loads every tool

MCP server: 12,500 tokens
CLI: Nothing

Every message, in Claude Code

MCP server: 760 tokens
CLI: Nothing

When Teachable comes up

MCP server: Nothing more, or in Claude Code the tools it picks
CLI: 1,300 tokens, once

20 messages with Teachable in one, every tool loaded

MCP server: 251,000 tokens
CLI: 1,300 tokens

Works in Claude Desktop's chat

MCP server: Yes
CLI: No, there's no terminal there

Works in a script, a cron job or CI

MCP server: No
CLI: Yes

What it costs	MCP server	CLI
Every message, in an app that loads every tool	12,500 tokens	Nothing
Every message, in Claude Code	760 tokens	Nothing
When Teachable comes up	Nothing more, or in Claude Code the tools it picks	1,300 tokens, once
20 messages with Teachable in one, every tool loaded	251,000 tokens	1,300 tokens
Works in Claude Desktop's chat	Yes	No, there's no terminal there
Works in a script, a cron job or CI	No	Yes

An app that loads every tool up front sends the full list with every message, whether you mention Teachable or not. Claude Code doesn't by default: its tool search sends only the tool names and the server's instructions, and loads a tool's full definition when your AI reaches for it.

The CLI costs nothing until Teachable comes up. Then your agent reads its skill file once and runs the commands it needs. With the skill added, Claude Code also lists its one-line description with every message, about 40 tokens.

When the whole conversation is about Teachable, the gap closes. Then the MCP server is the better experience, because you ask in plain language and your AI never has to look up a command.

How to spend less

In Claude Code, leave tool search on, which it is unless you've set ENABLE_TOOL_SEARCH=false.

Turn the server off when you aren't working on your school. In Claude Code that's the /mcp panel, and every AI app has its own switch. TEACHABLE_READ_ONLY=1 cuts it to the 19 reading tools.

Or install the CLI and connect the server later, on the days it earns its place. Every tool stays in reach, and the standing cost drops to nothing.

Every number here was measured on October 5, 2026 in Claude Code 2.1.286 with Claude Opus 5.5. It's the same one-line prompt with and without the server connected, once with tool search off so every tool loads, and once with Claude Code's default. The skill was measured the same way, and other apps and models count tokens a little differently.

Preview a batch, then run it

Changes that belong together, like enrolling a group of students, go through a batch. preview_school_batch checks up to 20 changes on your computer, without reaching Teachable, and gives you a fingerprint of exactly what will run.

submit_school_batch then runs only that batch, with that fingerprint and your approval. It stops at the first failure and tells you which changes ran and which didn't. Nothing is retried or rolled back on its own.

export_resources saves records, like your courses or your users, into a new private file: up to 10 pages and 1,000 items unless you ask for more. It never overwrites a file that's already there.

Pro tip: Teachable's version 2 API is a beta you request from Teachable. Once you have access, TEACHABLE_ENABLE_V2=1 adds 97 more tools, for coupons, comments, lecture content and more.

Every Teachable tool

The tables below list all 26 tools, grouped the way the repo groups them. Of these, 19 only read, and seven change something in your school.

Courses, lectures and quizzes

list_enrollments

What it does: The students enrolled in a course, with their progress.
Kind: Reads

mark_lecture_complete

What it does: Mark a lecture complete for a student.
Kind: Asks first

list_quiz_responses

What it does: The answers students gave to a quiz.
Kind: Reads

get_quiz

What it does: One quiz and its questions.
Kind: Reads

list_quizzes

What it does: The quizzes in a lecture.
Kind: Reads

get_video

What it does: One lecture video and its details.
Kind: Reads

get_lecture

What it does: One lecture and its content.
Kind: Reads

get_course_progress

What it does: One student's progress in a course.
Kind: Reads

get_course

What it does: One course and its details.
Kind: Reads

list_courses

What it does: Every course in your school.
Kind: Reads

Tool	What it does	Kind
`list_enrollments`	The students enrolled in a course, with their progress.	Reads
`mark_lecture_complete`	Mark a lecture complete for a student.	Asks first
`list_quiz_responses`	The answers students gave to a quiz.	Reads
`get_quiz`	One quiz and its questions.	Reads
`list_quizzes`	The quizzes in a lecture.	Reads
`get_video`	One lecture video and its details.	Reads
`get_lecture`	One lecture and its content.	Reads
`get_course_progress`	One student's progress in a course.	Reads
`get_course`	One course and its details.	Reads
`list_courses`	Every course in your school.	Reads

Students and enrollments

create_enrollment

What it does: Enroll a student in a course.
Kind: Asks first

unenroll_user

What it does: Remove a student from a course.
Kind: Asks first

get_user

What it does: One user and the courses they're enrolled in.
Kind: Reads

update_user

What it does: Change a user's name or sign-up source.
Kind: Asks first

list_users

What it does: Every user in your school.
Kind: Reads

create_user

What it does: Add a new user to your school.
Kind: Asks first

Tool	What it does	Kind
`create_enrollment`	Enroll a student in a course.	Asks first
`unenroll_user`	Remove a student from a course.	Asks first
`get_user`	One user and the courses they're enrolled in.	Reads
`update_user`	Change a user's name or sign-up source.	Asks first
`list_users`	Every user in your school.	Reads
`create_user`	Add a new user to your school.	Asks first

Pricing plans and sales

get_pricing_plan

What it does: One pricing plan and its details.
Kind: Reads

list_pricing_plans

What it does: Every pricing plan in your school.
Kind: Reads

list_transactions

What it does: Your school's sales. A new sale can take up to 2 minutes to show.
Kind: Reads

Tool	What it does	Kind
`get_pricing_plan`	One pricing plan and its details.	Reads
`list_pricing_plans`	Every pricing plan in your school.	Reads
`list_transactions`	Your school's sales. A new sale can take up to 2 minutes to show.	Reads

Webhooks

get_webhook_events

What it does: The events one webhook has sent.
Kind: Reads

list_webhooks

What it does: Your school's webhooks.
Kind: Reads

Tool	What it does	Kind
`get_webhook_events`	The events one webhook has sent.	Reads
`list_webhooks`	Your school's webhooks.	Reads

Batches, exports and your schools

list_accounts

What it does: The schools this server can act for, without showing any key.
Kind: Reads

get_operation_schema

What it does: What a tool would send to Teachable, before you run it.
Kind: Reads

preview_school_batch

What it does: Check a batch of changes on your computer, and get its fingerprint.
Kind: Reads

submit_school_batch

What it does: Run a previewed batch, stopping at the first failure.
Kind: Asks first

export_resources

What it does: Save records into a new private file.
Kind: Asks first

Tool	What it does	Kind
`list_accounts`	The schools this server can act for, without showing any key.	Reads
`get_operation_schema`	What a tool would send to Teachable, before you run it.	Reads
`preview_school_batch`	Check a batch of changes on your computer, and get its fingerprint.	Reads
`submit_school_batch`	Run a previewed batch, stopping at the first failure.	Asks first
`export_resources`	Save records into a new private file.	Asks first

Is the Teachable MCP server safe?

A change in Teachable reaches real students. An enrollment gives someone access, and unenrolling takes it away. So all seven tools that change something ask first. They're the ones marked "Asks first" in the tool tables above.

Nothing is retried on its own. If a change times out, check your school before you run it again, because it may have gone through.

When your AI calls one of them, the call needs a yes first. Where you use it decides who gives it:

Claude Code (2.1.246 and later) asks you before every call, in every one of its permission modes.
An app that can show forms asks you in a form.
Any other app takes your AI's confirm: true as the yes, so tell your AI to check with you first.
An agent with no person to ask needs TEACHABLE_CONFIRM=model, so its confirm: true counts in every app.
In a terminal, you add --confirm to the command.

If the answer is no, nothing reaches Teachable.

Make it read-only

Set TEACHABLE_READ_ONLY=1 and every change disappears from the tool list, leaving 19 reading tools. TEACHABLE_ALLOW_DESTRUCTIVE=0 refuses every change, even one you approve.

Keep a log of every write

Set TEACHABLE_AUDIT_LOG to a file path. The server writes one line per attempted write, allowed or blocked, with what it was about to do and who approved it.

Watch out: Student names, quiz answers and comments are written by other people, and one can try to give your AI orders. Treat them as data, and use TEACHABLE_READ_ONLY=1 for an agent working on its own.

Your data

Your requests go straight to Teachable's API, with no server of ours in between and no tracking. Your key stays in your app's config, your shell or your private file, and it never shows up in what your AI reads.

Student names and emails come back as they are, so keep your exports private. Uninstalling doesn't revoke the key. To cut access, revoke it in Teachable under Settings, API, More Actions, Revoke Key.

Connect more than one Teachable school

Set TEACHABLE_ACCOUNTS to a JSON list with a name and a key, or a key file, for each school, and TEACHABLE_DEFAULT_ACCOUNT to the one that acts when a tool names none. Every tool takes an optional account, so you can say which school a change is for.

Teachable MCP server settings

Every setting is an environment variable, in your app's config or your shell.

TEACHABLE_API_KEY

Default: none
What it does: Holds your school's API key

TEACHABLE_CREDENTIALS_FILE

Default: none
What it does: Points at a private JSON file with api_key, instead of the key itself

TEACHABLE_ACCOUNTS

Default: none
What it does: Lists several schools, as JSON

TEACHABLE_DEFAULT_ACCOUNT

Default: the first one
What it does: Picks the school that acts when a tool names none

TEACHABLE_API_VERSION

Default: 1
What it does: 2 uses the version 2 beta, once it's turned on

TEACHABLE_ENABLE_V2

Default: off
What it does: 1 shows the version 2 beta tools

TEACHABLE_READ_ONLY

Default: off
What it does: 1 hides every change

TEACHABLE_ALLOW_DESTRUCTIVE

Default: on
What it does: 0 refuses every change, even one you approve

TEACHABLE_AUDIT_LOG

Default: none
What it does: Names a file that gets one line per attempted write

TEACHABLE_REQUEST_TIMEOUT_MS

Default: 30000
What it does: Sets how long a request can take

TEACHABLE_MIN_REQUEST_INTERVAL_MS

Default: 1000
What it does: Spacing between requests

TEACHABLE_TOOLSETS

Default: all
What it does: Turns on only the toolsets you name, comma separated

TEACHABLE_SURFACE

Default: full
What it does: search lists three tools that find, describe and run the rest

TEACHABLE_TOOL_TIMEOUT_MS

Default: none
What it does: Gives up on any tool after this many milliseconds

TEACHABLE_CONFIRM

Default: human
What it does: model lets your AI's confirm: true approve on its own, for an agent with no person to ask

TEACHABLE_HTTP_PORT

Default: 8787
What it does: Sets the port for --http

TEACHABLE_HTTP_HOST

Default: 127.0.0.1
What it does: Sets the address for --http, and any other needs a token

TEACHABLE_HTTP_TOKEN

Default: none
What it does: Sets the bearer token every --http request needs

TEACHABLE_HTTP_ALLOWED_ORIGINS

Default: none
What it does: Lists other websites allowed to call --http, comma separated

TEACHABLE_DEBUG

Default: off
What it does: 1 prints debug lines

Variable	Default	What it does
`TEACHABLE_API_KEY`	none	Holds your school's API key
`TEACHABLE_CREDENTIALS_FILE`	none	Points at a private JSON file with `api_key`, instead of the key itself
`TEACHABLE_ACCOUNTS`	none	Lists several schools, as JSON
`TEACHABLE_DEFAULT_ACCOUNT`	the first one	Picks the school that acts when a tool names none
`TEACHABLE_API_VERSION`	`1`	`2` uses the version 2 beta, once it's turned on
`TEACHABLE_ENABLE_V2`	off	`1` shows the version 2 beta tools
`TEACHABLE_READ_ONLY`	off	`1` hides every change
`TEACHABLE_ALLOW_DESTRUCTIVE`	on	`0` refuses every change, even one you approve
`TEACHABLE_AUDIT_LOG`	none	Names a file that gets one line per attempted write
`TEACHABLE_REQUEST_TIMEOUT_MS`	`30000`	Sets how long a request can take
`TEACHABLE_MIN_REQUEST_INTERVAL_MS`	`1000`	Spacing between requests
`TEACHABLE_TOOLSETS`	`all`	Turns on only the toolsets you name, comma separated
`TEACHABLE_SURFACE`	`full`	`search` lists three tools that find, describe and run the rest
`TEACHABLE_TOOL_TIMEOUT_MS`	none	Gives up on any tool after this many milliseconds
`TEACHABLE_CONFIRM`	`human`	`model` lets your AI's `confirm: true` approve on its own, for an agent with no person to ask
`TEACHABLE_HTTP_PORT`	`8787`	Sets the port for `--http`
`TEACHABLE_HTTP_HOST`	`127.0.0.1`	Sets the address for `--http`, and any other needs a token
`TEACHABLE_HTTP_TOKEN`	none	Sets the bearer token every `--http` request needs
`TEACHABLE_HTTP_ALLOWED_ORIGINS`	none	Lists other websites allowed to call `--http`, comma separated
`TEACHABLE_DEBUG`	off	`1` prints debug lines

Troubleshooting

Run the doctor first. It names the step that failed and the fix.

What you see	What to do
Nothing is set up yet	Set one of `TEACHABLE_API_KEY` or `TEACHABLE_CREDENTIALS_FILE`, never both
Teachable answers 401 or 403	The key was revoked or lacks a permission, or your school can't use the API. Check the key in Settings, API
The version 2 tools don't show	Set `TEACHABLE_ENABLE_V2=1`, and ask Teachable for beta access
You hit a rate limit	Check what already went through, wait, then try again
An export refuses the file	Pick a new file name. It never overwrites a file
Claude Code asks before every change	That's the safety check working. Approve each change, or give a trusted agent `TEACHABLE_CONFIRM=model`

If the server doesn't show up in your app at all, run the command your app runs, in a terminal, and read the error.

More free tools for course creators

Email your students, or run your community, from the same AI app.

Free tools

MCP servers

Kit MCP server & CLI Circle MCP server & CLI

FAQs about the Teachable MCP server & CLI

Here are the questions people ask most about the Teachable MCP server and CLI.

What is the Teachable MCP server & CLI?

The Teachable MCP server & CLI is a free, open source program that lets an AI app like Claude, Codex or Cursor work in your Teachable school.

It has 26 tools for courses, lectures, quizzes, students, enrollments, pricing plans, sales and webhooks, and the same tools run as a CLI that agents like Claude Code and Codex use, or that you type yourself.

What is an MCP server?

An MCP server is a standard way to give an AI app real access to a tool, so it can act instead of guessing.

MCP stands for Model Context Protocol, and Claude, Codex, Cursor and many other AI apps speak it.

Every server I've made is on my MCP servers page.

What is the Teachable CLI?

The Teachable CLI is the same program as the Teachable MCP server, run as commands.

AI agents like Claude Code, Codex and OpenCode run them for you, and you can type them in a terminal or a script.

One npm package installs both.

Should I use the Teachable MCP server or the CLI?

Use the Teachable MCP server in an AI app with no terminal, like Claude Desktop's chat, and the CLI in a terminal, a script or a cron job.

In an AI app that can run commands, like Claude Code, Codex or Cursor, the CLI is the lighter choice, because it costs nothing until it runs.

Is the Teachable MCP server free?

Yes, the Teachable MCP server is free and open source under the AGPL-3.0 license.

The only things you pay for are your Teachable plan and your own AI app.

Do I need a Teachable developer account?

No, you don't need a developer account.

An API key from your school's settings, made by the school's owner, is all the Teachable MCP server needs.

Can it enroll students without asking me?

No, every enrollment and every other change waits for your approval.

Read-only mode removes the changes, so your AI can't see them at all.

What is the Teachable version 2 beta?

Version 2 is Teachable's newer API, which Teachable opens by request.

With access, TEACHABLE_ENABLE_V2=1 adds 97 more tools, for coupons, comments, lecture content and more.

Can I connect more than one Teachable school?

Yes, the Teachable MCP server connects as many schools as you set up in TEACHABLE_ACCOUNTS.

Every tool takes an optional account, and a default decides which one acts when you don't say.

How do I disconnect the Teachable MCP server?

To disconnect the Teachable MCP server, revoke its key in Teachable under Settings, API, which cuts access right away.

Then remove the server from your AI app's config.

Which AI apps does the Teachable MCP server work with?

The Teachable MCP server works with any app that speaks MCP.

That includes Claude Code, Claude Desktop, Codex, Cursor, VS Code, Windsurf, Zed, Cline, GitHub Copilot CLI, Gemini CLI, OpenCode, OpenClaw, Antigravity and Hermes.

Who made the Teachable MCP server & CLI?

I did.

I'm Navid Moazzez, and I made the Teachable MCP server & CLI as one of my free tools on navid.me.

You can read more about me.

The code is on GitHub under the AGPL-3.0 license, and the package is on npm.

More MCP servers & CLIs

View all

Kit MCP server & CLI

Draft newsletters, manage subscribers and tags, and read your email stats from Claude, Codex or Cursor.

NewslettersKit

Circle MCP server & CLI

Manage members and spaces, draft posts, and run events and courses, from Claude, Codex or Cursor.

Communities

Circle

Gumroad MCP server & CLI

Read sales and payouts, refund orders and manage products and license keys, from Claude, Codex or Cursor.

Gumroad

Bluesky MCP server & CLI

Post, read and search Bluesky from Claude, Codex or Cursor, or from your terminal.

Bluesky

Substack MCP server & CLI

Draft posts, publish Notes and check your stats on Substack from Claude, Codex or Cursor.

Newsletters

Substack

Threads MCP server & CLI

Post, reply and read your insights on Threads from Claude, Codex or Cursor.

Threads

Mastodon MCP server & CLI

Post, edit and read your timelines on any Mastodon instance from Claude, Codex or Cursor.

Mastodon

TikTok MCP server & CLI

Rank your videos, read your stats and publish to TikTok from Claude, Codex or Cursor.

TikTok

ThriveCart MCP server & CLI

Check revenue, customers, subscriptions and affiliates in ThriveCart from Claude, Codex or Cursor.

ThriveCart

WordPress MCP server & CLI

Edit posts, pages, Elementor and Rank Math SEO on WordPress from Claude, Codex or Cursor.

Blogs

WordPress

Midjourney MCP server & CLI

Generate images, follow jobs and download the files from Midjourney with Claude, Codex or Cursor.

AI images

Midjourney

Google Photos MCP server & CLI

Pick photos, build albums and upload to Google Photos from Claude, Codex or Cursor.

Photos

Google Photos

Apple Photos MCP server & CLI

Search, look at and organize your Apple Photos library from Claude, Codex or Cursor, on your Mac.

Photos

Apple Photos

Apple Podcasts MCP server & CLI

Track chart ranks, read reviews and search your podcast library from Claude, Codex or Cursor.

Podcasts

Apple Podcasts

Podcast Index MCP server & CLI

Search 4 million podcasts and read episode transcripts from Claude, Codex or Cursor.

Podcasts

Podcast Index

Google Search Console MCP server & CLI

Read your search traffic, check indexing and submit sitemaps from Claude, Codex or Cursor.

SEO

Google Search Console

Google Workspace MCP server & CLI

Work across Gmail, Drive, Sheets, Docs and Calendar from Claude, Codex or Cursor.

Productivity

Google Workspace

iMessage MCP server & CLI

Catch up, search your history and send iMessages from Claude, Codex or Cursor, on your Mac.

Messaging

iMessage

Facebook MCP server & CLI

Read your Page insights, schedule posts and moderate comments, from Claude, Codex or Cursor.

Facebook

Facebook Ad Library MCP server & CLI

Research the ads any brand runs on Facebook and Instagram, from Claude, Codex or Cursor.

Research

Facebook

Vimeo MCP server & CLI

Read transcripts, file videos into folders and add chapters from Claude, Codex or Cursor.

Vimeo

YouTube MCP server & CLI

Read any video's transcript, research channels and manage your own from Claude, Codex or Cursor.

YouTube

Telegram MCP server & CLI

Catch up, search years of chats and reply on Telegram from Claude, Codex or Cursor.

Messaging

Adobe Firefly MCP server & CLI

Generate and edit images with Image 5, make video and composite products from Claude, Codex or Cursor.

AI images

Adobe Firefly

OP3 MCP server & CLI

Read your podcast's downloads, real listeners and retention from Claude, Codex or Cursor.

Podcasts

OP3

Beehiiv MCP server & CLI

Draft posts, manage subscribers and segments, and read your stats, from Claude, Codex or Cursor.

NewslettersBeehiiv

Calendly MCP server & CLI

Find open times, book and cancel meetings, and read meeting recaps, from Claude, Codex or Cursor.

Calendly

Wistia MCP server & CLI

Upload and organize videos, fix captions and read your analytics, from Claude, Codex or Cursor.

Wistia

ScrapeCreators MCP server & CLI

Research public profiles, posts, transcripts and ads across social platforms, from Claude, Codex or Cursor.

ScrapeCreators

Shotstack MCP server & CLI

Render videos from templates, make AI clips and manage hosted files, from Claude, Codex or Cursor.

Shotstack

Gumloop MCP server & CLI

Run flows, work with your agents and search your Company Brain, from Claude, Codex or Cursor.

Productivity

Gumloop

Buffer MCP server & CLI

Draft and schedule posts, manage your queues and read your analytics, from Claude, Codex or Cursor.

Buffer

Cloudflare MCP server & CLI

Manage DNS records, clear the cache and change domain settings, from Claude, Codex or Cursor.

Productivity

Cloudflare

Bannerbear MCP server & CLI

Make images, animations and videos from your templates, from Claude, Codex or Cursor.

AI images

Bannerbear

Brandfetch MCP server & CLI

Get any brand's logos, colors and fonts, and compare brands, from Claude, Codex or Cursor.

Research

Brandfetch

Creatomate MCP server & CLI

Edit templates, check renders for free and make videos and images, from Claude, Codex or Cursor.

Creatomate

Dub MCP server & CLI

Create short links, read clicks and sales, and run your partner program, from Claude, Codex or Cursor.

Dub

fal.ai MCP server & CLI

Find models, check prices, and generate images and videos, from Claude, Codex or Cursor.

fal.ai

Flodesk MCP server & CLI

Manage subscribers, segments and workflows, and draft campaigns, from Claude, Codex or Cursor.

SalesFlodesk

Fluent WordPress MCP server & CLI

Work with FluentCRM, FluentCommunity and Fluent Forms on your WordPress site, from Claude, Codex or Cursor.

WordPress

Senja MCP server & CLI

Find, approve and tag testimonials, send invites and export them, from Claude, Codex or Cursor.

Senja

Testimonial.to MCP server & CLI

Read, import and export your testimonials, and send request emails, from Claude, Codex or Cursor.

Testimonial.to

Lemon Squeezy MCP server & CLI

Read and refund orders, manage subscriptions and check license keys, from Claude, Codex or Cursor.

Lemon Squeezy

Fourthwall MCP server & CLI

Manage products and orders, ship them, and run promotions and giveaways, from Claude, Codex or Cursor.

Fourthwall

Related free tools

All free tools

Online course idea generator

Course ideas built around your topic, from a mini course to a cohort, with real teachers' results.

Online course revenue calculator

What your online course earns a month on each platform, after its fees, and the price that reaches your goal.

Online course platform comparison

What 55 course, community and checkout platforms cost you, fees included, cheapest first.

Course platform finder

The course platforms that have what you need, ranked by what they'd cost you.

X character counter

Counts the way X counts: links as 23, emoji as 2. LinkedIn, Instagram, TikTok, Threads and YouTube limits too.

Bluesky

Instagram

LinkedIn character counter

LinkedIn's 3,000-character post limit, counted as you type, with X, Threads and Bluesky beside it.

Threads character counter

Threads' 500-character limit, counted as you type, with X, Bluesky and LinkedIn beside it.

Threads

Bluesky character counter

Bluesky's 300-character limit, counted the way the protocol counts, with X and Threads beside it.

Bluesky

Mastodon character counter

Mastodon's 500-character default, counted the way Mastodon counts links and mentions.

Mastodon

Instagram character counter

Instagram's 2,200-character caption limit, counted as you type, with TikTok and the rest beside it.

Instagram

TikTok character counter

TikTok's 2,200 caption limit, counted the way TikTok counts it, with emoji as 2.

TikTok

Pinterest character counter

Pin titles (100) and descriptions (800), counted as you type.