How I Audited a HubSpot Portal Using AI + MCP (and What You Can Try)

I'm a CRM admin who loves efficiency, especially when it comes to understanding what's actually happening in a HubSpot portal. I recently ran an audit using HubSpot’s Model Context Protocol (MCP), and it completely changed how I think about diagnosing CRM health. In this post, I want to share what I found, how I did it, and how you can try it too. If you're a HubSpot admin, marketer, or someone who’s ever stared into a pile of workflows wondering what’s still doing anything, you’ll want to read this.

Why I Used MCP

If you've ever opened up a complex HubSpot portal and tried to answer questions like:

• "Are all my custom object associations still working?"

• "Which workflows are still active or silently broken?"

• "Is my custom code still doing what I think it’s doing?"

you know that it can take hours (if not days) to get a clear answer. You jump between automation tabs, search for custom fields, manually trace object relationships, and hope you're not missing anything critical. I wanted a smarter way to see the structure of a portal and flag things that might be off. That's where MCP comes in. It's a lightweight framework that lets you model, query, and validate the shape of CRM systems. With it, I could turn my portal into something I could actually inspect. I could even automate that inspection. It’s like turning your HubSpot portal into something with an x-ray view.

What I Audited

The portal I audited was a good one. It was a mature setup with custom objects for registrations, programs, franchises, and participants. The object relationships were thoughtfully designed. ID-based links were used properly. There was a clear architecture for mapping people to places and roles.

There were plenty of strong points:

• Object naming was consistent and clearly labeled.

• Registration pipelines were aligned to territories.

• Marketing campaigns were thoughtfully mapped to seasonal timelines.

• Team permissions were well-scoped to match responsibilities.

But there were also some surprises:

• Many workflows were inactive, including key association flows.

• There was heavy use of custom JavaScript in workflows, with limited error handling.

• Delay branches were used to retry automation logic. This was creative, but potentially risky at scale.

• Several data sync workflows were doing redundant property copying between objects.

None of this was bad. It showed how easy it is for even a well-run portal to end up with quiet problems, especially when teams grow and processes layer on top of each other. MCP helped surface all of this in a clean, organized way. Most importantly, it made it easy to explain and prioritize what needed cleanup.

How I Used MCP

I connected the portal to MCP using a HubSpot Private App. I gave it the scopes it needed for objects, schemas, users, workflows, and automation. Then I pointed MCP to the token and kicked off a portal introspection run. It took just a couple of minutes to return a detailed, structured snapshot of the entire system.

MCP pulled down:

• A full object schema, including custom and standard objects.

• Custom property groupings, labels, and descriptions.

• Active and inactive workflows.

• Association definitions and gaps.

• Embedded custom code and external API calls in workflows.

All of this came back as structured data I could review, validate, and even share as a snapshot with others. It was like going from a mystery maze to having a map in hand. Even better, my conversations with stakeholders will be easier because we had clear evidence of what was happening.

What You Can Try Today

If you’re a HubSpot admin, power user, or someone curious about CRM architecture, here’s how you can use MCP to run your own audit:

1. Set up MCP

   • Create a private app in HubSpot and generate a token.

   • Install MCP locally using npx or set it up serverless via your preferred platform.

2. Connect Your Portal

   • Add a config block for HubSpot and feed in the token.

   • Run the audit to pull a full model of your portal.

   • You can store the output locally, view it in a terminal, or transform it into a readable report.

3. Start Validating

   • Look for inactive workflows tied to critical objects like registrations or programs.

   • Check that your ID-based associations are consistently populated.

   • Use a rule to flag custom code blocks or missing error handling.

   • Review property usage frequency to identify redundant fields.

4. Ask AI to Help

   • Once you have the output, you can even feed it into GPT and ask:

     • "Which objects aren't associated properly?"

     • "Which workflows are disabled but tied to core objects?"

     • "What are my top three automation risks?"

     • "Show me property groups that aren’t used by any workflows."

Even if you don’t go deep into automation logic, you’ll walk away with a clearer sense of how your portal is wired and where you might want to clean things up.

Behind the Scenes: Why I Tried MCP

So why did I actually try this out? I love pushing into the new areas HubSpot is building. I want to stay on the edge because I never know what’s going to shave hours off my workweek or unlock a new way to build a better customer journey. MCP felt like one of those tools. I’d only heard a bit about it before, but when HubSpot launched their official support for it, I decided to give it a real test drive.

Setup was fast. It was just a matter of installing it locally with npx and adding a quick config block to my JSON. (Pro tip: watch your brackets. My only snag was a missing curly brace.) In five minutes, I had my first model of the entire portal.

Here’s the part that surprised me. I thought I had a pretty good handle on what was active and running in the portal. But MCP showed me just how much we were really doing and how much of it had been quietly turned off. Some of that was expected. We’d recently made a big portal shift. MCP helped me quickly separate what was obsolete from what needed immediate cleanup.

A few workflows had no error handling at all. They weren’t causing damage yet, but I could see how a customer might slip past unnoticed if left running. That alone made it worth the run.

It also gave me some instant wins. I found areas to clean up for better organization, and I could see a future where I use MCP and AI to prompt smarter audits. Things like "show me any association workflows not connected to active objects" or "what’s the oldest running workflow still tied to a lead stage?"

If you only have 20 minutes, I’d start by connecting your portal and asking it to give you a high-level overview. What’s active, what’s off, and where could you improve? No need to dive deep. Just treat it like asking a second pair of eyes to spot check your setup.

And if you’re on the fence? Just dive in. Set up a private app with read-only scopes. Install @hubspot/mcp-server, and check out the official HubSpot developer guide. You don’t need a dev background to get value. You just need curiosity and a little patience.

Advanced Takeaways and Clean-Up Wins

After reviewing the MCP output, one of the most valuable realizations was that every disabled workflow was tied directly to our recent portal restructuring. That wasn't a problem—it was a prompt. It helped me isolate and prioritize areas that needed to be cleaned up or deprecated.

But what stood out more were workflows containing custom code that had silent failures. MCP flagged several automations that technically completed successfully, but due to missing error handling, didn’t perform the actions they were intended to. These weren’t throwing errors, which means they could have gone unnoticed for weeks or longer. That was the real pain point: assuming success because there was no failure, when in reality, key customer steps weren’t being executed.

Using MCP, I was able to:

• Identify and correct these silent failures.

• Scale down duplicate processes that had grown over time.

• Kick off a structured cleanup plan that aligns better with our current architecture.

Here’s a quick look at the config I used:

{
  "mcpServers": {
    "hubspot-ORG1": {
      "command": "npx",
      "args": ["-y", "@hubspot/mcp-server"],
      "env": {
        "PRIVATE_APP_ACCESS_TOKEN": "..."
      }
    },
    "linear": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.linear.app/sse"]
    }
  }
}

I run multiple portal audits this way, each scoped cleanly under a different MCP alias. This lets me build side-by-side comparisons, automate recurring checks, and eventually add validation rules over time. With each run, I’m not just inspecting—I’m maintaining, optimizing, and proactively improving.

Real Output, Real Wins

To give you a better feel for what MCP actually shows you, here are a few direct (redacted) examples from my audit output. These are exactly the kinds of insights that help you move from guesswork to action.

Silent Failures in Custom Code

{
  "workflow": "Onboarding - JS Handler",
  "actionType": "CUSTOM_CODE",
  "status": "SUCCESS",
  "note": "No error logging defined"
}

This workflow looked fine at a glance, but it had no error handling. MCP flagged that, and sure enough, the function was skipping core logic silently. I fixed the issue and added proper logging—something I wouldn't have caught otherwise.

Redundant Property Sync Workflows

{
  "workflow": "Object Sync - Email Copy",
  "type": "Property Sync",
  "sourceProperty": "********_email",
  "destinationProperty": "contact_email",
  "redundant": true
}

This one was a quick win. The workflow was duplicating what our associations already handled. By removing it, we cleaned up unnecessary logic and reduced complexity across our automation setup.

High-Level Summary Snapshot

{
  "summary": {
    "totalObjects": 7,
    "customObjects": 5,
    "workflows": {
      "active": 37,
      "inactive": 59,
      "customCode": 14
    }
  }
}

With a single command, I got a complete breakdown: total objects, active vs. inactive workflows, and how many were using custom code. That became the basis for our cleanup roadmap and prioritization.

Final Thoughts

You don’t need to be a developer to run MCP. You just need curiosity and a desire to understand your portal’s structure better. For me, it turned a black-box system into something I could walk through, check, and improve. Now it’s something I can run on any new portal I’m working with. It’s like turning on a light in a cluttered room.

Even just running MCP once gave me insights I hadn’t seen with manual review. It’s now part of how I think about CRM hygiene and how I make sure nothing is falling through the cracks. It’s a boost to transparency, speed, and confidence.

If you're looking for a new way to level up your HubSpot admin skills or just get a better understanding of what's going on under the hood, I highly recommend trying HubSpot’s MCP. It's fast, flexible, and feels like giving your CRM a check-up with AI at your side.

Give it a try. I think you’ll be surprised how much you can learn about your portal with just one run.