How to build a Notion database with the HubSpot Dev MCP and Claude Code

Consider what goes into building with a new MCP server. You're not just learning a new tool; you're learning a workflow with its own patterns, edge cases, and best practices. HubSpot's Dev MCP is well-designed (if I do say so myself!) and the docs are thorough, but with 20+ tools across projects, CMS, apps, and documentation; there's a lot of territory to cover. This isn't unique to HubSpot... it's the reality of picking up any MCP server worth building with.

Figuring out what an MCP server can do for you, and how it's meant to fit into your workflow, is the real lift - and every MCP server handles it a little differently.

What if the MCP server could just tell you what it does?

In this post, I'll show you how to use HubSpot's Dev MCP with Claude Code to auto-generate a live Notion database of every tool the MCP exposes. I'll use the HubSpot Dev MCP and a Notion database as my example, but the pattern holds for any MCP server you pick up: Linear, Asana, Slack, your own internal one; and any destination you want the reference to live in: a reusable claude code skill, a markdown file, or a slack canvas. The setup I'll walk through lets you skip the guessing and get to a usable capabilities reference in about ten minutes.

This is a starting point. Once your team's reference lives in Notion, you can start using Notion the other direction too, as the place your agents look for instructions, business logic, and team-specific patterns. More on that in another blog :)

Sound good? Let's build.

MCP Servers are moving faster than the docs can

My experience, as someone who spends every day working with builders picking up new MCPs, is that MCP servers are having a moment. Every platform worth building on is shipping one, and builders are picking up three, four, five of them at a time to stitch across their workflows.

The pace of MCP development right now is faster than any docs team can realistically keep up with (and I say that as someone who works with a great docs team!). Tools get added, renamed, deprecated, and reorganized between releases. A doc that was accurate last month is already stale this week. And if you're the builder trying to figure out what a given MCP server can actually do for you, you're the one left paying for that lag.

That's great for capability, but not so much for discoverability.

In my opinion, the answer to that isn't waiting for better docs. The answer is pulling the source of truth from the code itself, on demand, and dropping it into a format you can actually use.

That's what I'm going to show you how to do.

Setting up: install the Dev MCP

Run this command in your terminal:

hs mcp setup

With this command, the HubSpot Dev MCP is wired into Claude Code. Your environment now has access to:

• 20 tools across 4 categories
• Documentation search directly from the MCP
• Project scaffolding and deployment
• CMS module and function creation
• Account and app introspection

No restructuring required, but you will need a few prerequisites.

Prerequisites

Required:

• Claude Code, installed in VS Code
• Node.js 20 or later
• A HubSpot developer account with a private app access token (sign up for free here)
• A Notion account and an integration token
• The HubSpot Dev MCP set up in your Claude Code environment

Environment variables you'll add to your project's .env once it's created:

NOTION_API_KEY=ntn_xxxxxxxxxxxxxxxxxxxxxxx

NOTION_PAGE_ID=your_page_id_here

What's in the Dev MCP

The HubSpot Dev MCP ships with +20 tools across four categories. Each one does something specific and each one gets its own row in the matrix you're about to build.

You don't have to memorize any of this. That's the whole point of what you're about to build.

This order matters: ask before you build

I asked Claude Code what the HubSpot Developer MCP does before I tried to do anything with it. That's the move some of us skip because it feels too obvious. It's also why capability confusion keeps winning.

The MCP server already knows what tools it exposes. All you're doing is asking for that list, then handing it to Claude Code and telling it where to put the answer.

This pattern works on any MCP server. Not just HubSpot's. Swap the tool list, swap the destination, and you've got a capabilities reference for whatever you're building with: Linear, Asana, Slack, your own internal MCP, anything.

Here's the workflow:

1. Ask the MCP Server what it does. One prompt. Returns the full tool list.
2. Hand the list to Claude Code. One prompt. Scaffolds the whole project.
3. Run the script. One command. Populates the Notion database.
4. Keep it fresh. Re-run whenever something feels off.

Got all that? Let's go.

Step 1: Ask the MCP what it can do

Here's the move most builders skip because it feels too obvious. Open Claude Code. In the chat, type this:

List all the MCP tools available to you from HubSpot

That prompt asks Claude Code to query the MCP directly and return the real list. When I ran this, the HubSpot Dev MCP returned 20 tools across four categories:

Documentation

• search-docs — search HubSpot developer documentation
• fetch-doc — fetch full content of a docs page by URL
  
  Account & Apps

• get-applications-info — list all HubSpot apps in the connected account
• get-api-usage-patterns-by-app-id — get API usage patterns for a specific app
• create-test-account — create a HubSpot sandbox

Projects & Deployment

• create-project — scaffold a new HubSpot project
• add-feature-to-project — add a feature (app card, function, etc.)
• deploy-project — deploy a HubSpot project
• upload-project — upload project files to HubSpot
• validate-project — validate a project's config before deploying
• get-build-status — check the build status of a project
• get-build-logs — retrieve build logs
• get-feature-config-schema — get the config schema for a project feature
• guided-walkthrough-cli — step-by-step CLI walkthroughs

CMS

• create-cms-function — create a CMS serverless function
• create-cms-module — create a CMS HubL module
• create-cms-template — create a CMS page template
• list-cms-remote-contents — list contents of a CMS project remotely
• list-cms-serverless-functions — list serverless functions in a CMS project
• get-cms-serverless-function-logs — fetch logs for CMS serverless functions

Copy that list. You'll feed it into the next prompt.

*For the most current list of MCP tools in our MCP server see our documentation.

Step 2: Set up Notion

Head to notion.so/my-integrations and create a new integration. Name it whatever makes sense, I called mine DevMCP Matrix. Grab the secret key it generates. It starts with ntn_.

Then open your Notion workspace and create a blank page. This is where the database will land.

Two things to do on that page:

1. Copy the page ID from the URL. It's the long string of characters at the end. No dashes, no query parameters.
2. Connect the integration to the page. Click the "..." menu → Connections → search for the integration you just made → add it.

Skip step 2 and the script fails with a 404 that'll send you down a debugging rabbit hole. Learned that one the hard way. Don't skip it.

Step 3: Have Claude Code build the script

Back in Claude Code, paste this prompt. Drop the tool list from Step 1 where indicated:

Build a Node.js project that creates a Notion database from the tools exposed by the HubSpot Dev MCP. Look up the available tools directly from the MCP server.

The Notion database should have these columns:

- Tool Name (title)

- Category For HubSpot Dev MCP (select: Documentation, Account & Apps, Projects & Deployment, CMS). For other generic MCP servers (select: derive the categories from how the MCP groups its tools)

- Action Type (select: Read, Create, Deploy, Utility)

- Description

- Input Parameters

- What It Returns

Use @notionhq/client. Create a .env file for NOTION_API_KEY and NOTION_PAGE_ID.

Claude Code scaffolds the entire project. Package.json, index.js, .env template. Dependencies installed.

Just that one prompt, and that's the whole build step.

Step 4: Run it

Open the .env file Claude Code created. Drop in your Notion integration token and the page ID from Step 2.

From the terminal:

npm install

npm start

The script connects to Notion, creates the database on your page, and writes one row per tool. All 20 rows populate in a few seconds.

Flip over to Notion. Every tool. Every category. Every description, input, and return value, sitting in a single filterable table.

That's the whole build. Things that used to take a week of doc-wrangling now take about ten minutes.

HubSpot MCP Tools Matrix

Want to take it one step further?

Back in Claude Code, with the matrix fresh in your context, run one more prompt:

"Based on these 20 tools, walk me through how I'd use the HubSpot Dev MCP in my day-to-day work as a developer building on HubSpot. Give me three common scenarios, like scaffolding a new project, debugging a failed deploy, and creating a CMS module. Then show me which tools I'd chain together for each one."

Now you're not just looking at what the HubSpot Dev MCP can do; you're looking at how you're meant to use it.

Keeping it current

The script you just built runs in a few seconds. Re-run it whenever something feels off, or wire it to a GitHub Action that runs on a schedule.

If you want to get more out of it, point the script to HubSpot Dev MCP Tools instead of a Notion database and you've got auto-updating docs. You can also pipe it into a Slack canvas and the whole team can get a live reference.

Haven’t started your journey yet?

Run this to get started:

hs mcp setup

Then open Claude Code and ask the HubSpot Developer MCP what it can do. Two prompts. One Notion database. Twenty tools mapped. A pattern that works on any MCP server you pick up, portable to any project.

Obviously (hopefully!) my intention here isn't to replace docs or the teams building them. This is an augmentation strategy, a way to close the gap between when an MCP server ships a new tool and when a builder actually knows it exists. Getting past the "what can this thing even do?" problem, and giving you a reference that lives where your team already works.

The MCP servers exist. The tools exist. Now you can ask any MCP server to document itself.

I can't wait to see what you build!