Hubspot Developers Updates & Release Notes

Create, update and test custom code workflow actions with Breeze Assistant

Breeze Assistant can now write, test, and iterate on custom code workflow actions. Describe what you want the action to do in plain language, and Breeze generates the full code — including input definitions, logic, and data outputs — ready for you to review, edit, and save. Previously, Breeze Assistant was limited to assembling workflows from HubSpot's standard actions or available third-party app actions.

To use it, open Breeze Assistant in Workflows and describe the action you want to build. You can specify your preferred language (defaults to JavaScript), which object properties to use as inputs, and expected outputs. Breeze generates the action, and you review it in the standard custom code editor before anything saves. Edit it directly to tune the logic, swap libraries, or adjust outputs.

A couple things to keep in mind: Secrets (API keys, tokens) are managed through the existing Manage secrets flow — Breeze references them by name in the code but never stores or sees the actual values. Testing from Breeze Assistant or the built-in test panel executes the action against a real record and can mutate it, just like using the standard Test flow in the UI.

No action required. This feature is now available for Data Hub Professional and Enterprise accounts.

New useCrmSearch Hook for UI Extensions

You can now use the new useCrmSearch React hook for UI extensions to search the CRM directly from app cards and app pages. You can now search, filter, and paginate across any CRM object type, including contacts, companies, deals, tickets, and custom objects, using free-text queries and structured filter groups, with built-in property formatting.

To use the hook, import it from the UI extension directory with import { useCrmSearch } from '@hubspot/ui-extensions' and pass a config object specifying the object type, properties to return and optional free-text queries and filter groups.

Learn more about the hook in our developer docs.

Blog Posts Can Now Be Attributed to Multiple Authors

You can now assign multiple authors to a single blog post for more accurate attribution. In the blog post settings, you can select multiple authors to attribute to a post.

Before assigning multiple authors to a single blog post, you must update the blog post templates to handle multiple authors. When using HubSpot’s default templates, assigned multiple authors will be displayed automatically.

To update your blog templates to feature multiple blog authors, use the HubL syntax content.blog_author_list. This will allow you to output a list of all authors associated with a specific blog post. From there, you can loop through the list of blog authors to display them on the post.

Example for loop:

{% set authors_to_display = content.blog_author_list if content.blog_author_list and content.blog_author_list|length > 0 else [content.blog_author] if content.blog_author else [] %}
{% if authors_to_display and authors_to_display|length > 0 %}
  <div class="blog-meta">
    <div class="blog-meta__avatars">
      {% for author in authors_to_display %}
        <div class="blog-meta__image-container">
          <img src="{{ author.avatar or get_asset_url('../images/avatar-placeholder.jpg') }}" alt="{{ author.display_name|escape_attr }}" width="48" height="48">
        </div>
      {% endfor %}
    </div>

    <div class="blog-meta__content">
      <div class="blog-meta__authors">
        {% for author in authors_to_display %}
          {% if author.display_name %}
            {{ author.display_name|sanitize_html }}{% if not loop.last %}{% if loop.revindex == 2 %}, and {% else %}, {% endif %}{% endif %}
          {% endif %}
        {% endfor %}
      </div>
    </div>
  </div>
{% endif %}

Stage Calculated Properties for Custom Objects

Custom objects can now have stage calculated properties that automatically track how records move through pipeline stages. These properties function the same way as the stage calculated properties that already exist for standard objects like tickets and deals.

See the product update for more details.

HubSpot IP Ranges Webhooks

Introducing webhook notifications for HubSpot IP range changes. Customers can now subscribe to receive notifications when HubSpot’s published IP ranges are added, modified, or removed, allowing them to proactively update their firewall rules and network configurations.

We previously announced email notifications for account admins. Now webhook notifications are available via the IP Ranges API. Customers can register a webhook endpoint to receive callbacks when IP ranges change.

See the documentation for more details.

Reminder: Legacy CRM Cards Deprecation for October 31, 2026

This is a reminder that support for legacy CRM cards built with the CRM Extensions API is being deprecated on October 31, 2026. This deprecation was originally announced on May 15, 2025.

What's changing?

Legacy CRM cards built with the legacy CRM Extensions API will no longer be supported on October 31, 2026. After that date, legacy CRM cards will no longer render in HubSpot CRM records. This does not affect UI Extensions built with Projects. Only legacy cards created via the legacy CRM Extensions API (/crm/v3/extensions/cards and related endpoints) are impacted.

Key dates and next steps:

• May 15, 2025: Deprecation originally announced
• October 31, 2026: Classic CRM cards stop rendering. The CRM Extensions API endpoints supporting classic cards will be removed.

To get ready:

• Audit any apps using the CRM Extensions API to identify classic CRM cards that need to be migrated.
• Rebuild impacted cards as UI Extensions and the Projects framework.
• Test migrated cards in a developer account before the October 31, 2026, deadline.

Helpful resources:

• App cards overview
• Migrate a legacy CRM card to an app card
  • Legacy CRM Card to UI Extension Converter
  • Migrating Legacy CRM Cards to App Cards Demo

Unformatted Number properties now support decimals

Users can now enter decimal values into CRM properties configured with the “Unformatted Number” field type. Previously, these properties only accepted whole numbers, which created limitations for use cases requiring more precise numeric values.

This update removes a key usability barrier and expands support for workflows and integrations that rely on decimal-based data.

HubSpot CLI updates: improve project uploads, account linking, and local development

Recent HubSpot CLI releases introduced several updates to make project development and deployment more reliable. Project uploads now support NPM workspaces, include stronger audit and ESLint validation, support --skip-npm-audit, and correctly return failed exit codes when build or deploy steps fail. The CLI also adds hs project app-install-status for checking app installation state, --use-env support for project commands, and custom local development ports with hs project dev --port.

Account management has also been improved with the new hs account link and hs account unlink commands, which let developers scope authenticated accounts to a specific directory. These releases also include expanded MCP tooling, clearer debug and command failure logs, improved project linting, updated “Content Hub” terminology, and fixes for sandbox creation timeouts, version reporting, CMS serverless function defaults, and multi-function project logs.

Upgrade the CLI with npm install -g @hubspot/cli and learn more in the HubSpot CLI commands overview.

HubSpot CLI introduces global authentication with directory-level account linking

The HubSpot CLI now uses a global authentication model with per-directory account linking, helping developers manage authenticated accounts from a single source of truth. Developers can authenticate accounts globally, then use hs account link to associate specific accounts with a project directory, set a local default with hs account default, view the active context with hs account current and remove linked accounts with hs account unlink.

This update reduces duplicated repo-local configuration and makes it clearer which account a project is using, helping prevent accidental deployments to the wrong account. Existing legacy .hsaccount files are migrated to the new .hs/settings.json format automatically where possible.

Learn more in the HubSpot CLI account commands reference.

Public Betas

Manage Stage Calculated Properties by Pipeline

Users can now control which pipelines and pipeline stages generate stage calculated properties (SCPs). By default, SCPs are disabled for new custom pipelines and stages but can be enabled anytime. Previously, SCPs were automatically created for every pipeline and stage, which could add hundreds or thousands of properties to an account whether they were needed or not. If your integration uses stage calculated properties, you will need to account for those properties not being created for all custom pipelines.

This feature is currently in public beta. See the product update for more details and to join the beta to test this feature.

Custom URL support in the telemetry component

The HubSpot telemetry component now supports routing data to a custom backend. Previously, telemetry export was limited to Sentry and Honeycomb. With this update, you can now direct app telemetry data to any backend you control.

To use it, follow the telemetry setup guide (https://developers.hubspot.com/docs/apps/developer-platform/add-features/add-telemetry) and set providerType to CUSTOM_BACKEND, then add an endpointUrl field pointing to your backend. HubSpot will forward your app's telemetry data to that endpoint.

This feature is available in public beta on the Developer Platform.

Questions or comments?

Please join us in our developer forums.

Original source

Beginning May 26, 2026, the ability to create new legacy public apps via the Developer Platform UI will be permanently disabled. New public app development should use the Projects-based app platform.

What's changing?

The Developer Platform UI will no longer allow the creation of new legacy public apps. The rollout occurs on two timelines based on account creation date:

• New accounts (created on or after May 26, 2026): Legacy public app creation is disabled as of May 26, 2026.
• Existing accounts (created before May 26, 2026): Legacy public app creation is disabled as of June 23, 2026.

Existing legacy public apps are not affected by this change. They will continue to function as-is. Existing or new legacy private apps are also not affected at this time. A separate migration initiative, with its own timeline and tooling, will address the migration of existing legacy public apps to the Projects-based platform.

How it works

To create apps intended for listing in the Marketplace, use the HubSpot CLI with Projects-based tooling. Project-based apps support CLI-based workflows, UI extensions, app cards, and dedicated deployment tooling. Follow the developer documentation to set up your environment and create your first project-based app.

Key dates and next steps:

• May 26, 2026: Legacy public app creation is disabled for all accounts created on or after this date.
• June 23, 2026: Legacy public app creation is disabled for all accounts created before May 26, 2026.

To get ready:

• If you are building a new app intended for the Marketplace, begin using the Projects-based platform now.
• Review the HubSpot CLI and Projects documentation to set up your development environment.
• No action is required to maintain existing legacy public apps — they continue to function without interruption.

Helpful resources:

• Projects-based app developer documentation
• HubSpot App Marketplace listing requirements
• Migration guide for existing legacy public apps

Questions or concerns?

Join us in the Developer Community Forum for a peer-to-peer discussion.

Original source

Unsupported developer platform + API versioning requirements

We're updating the requirements for listed and certified apps in the HubSpot Marketplace to align with current platform standards and deprecations. These updates ensure that apps stay compatible with HubSpot's evolving platform and APIs, providing customers with a more reliable, secure experience.

HubSpot releases a new version of its developer platform and REST APIs every 6 months (March and September). Each release includes a transition period before previous versions become unsupported. To ensure apps are built on supported, up-to-date platform versions:

• Use of supported versions: Apps must use a currently supported version of HubSpot’s developer platform and APIs (latest version recommended).
• Marketplace listings: New apps built on unsupported platform versions will be rejected from being listed
• Certification & recertification: Apps must be on a supported developer platform and API version at the time of review. A defined remediation window will be provided if updates are required.

Enforcement timeline:

• Starting November 2, 2026:
  • Apps must be on a supported developer platform version (v2025.2 or v2026.03).
  • Apps using legacy apps or Projects 2023.2 / 2025.1
    • will be rejected for new listings
    • Apps undergoing certification or recertification will have ~60 days to migrate to a supported version
• Starting March 2027:
  • v4 APIs will become unsupported
    • Apps undergoing certification or recertification will have ~60 days to migrate

Legacy CRM card deprecation requirements

Legacy CRM cards will be fully deprecated on October 31, 2026. To support this transition:

• Effective immediately, legacy CRM cards are no longer permitted for new app listings, certifications, or recertification submissions.
• If your app currently uses legacy CRM cards, you must migrate to app cards to be eligible.
• All other listed and certified apps must migrate by October 31, 2026.

Uninstall app endpoint usage requirement

For all new app certification submissions and apps undergoing recertification, your app must use the Uninstall App API endpoint:

DELETE /appinstalls/v3/external-install

This endpoint requires an active OAuth access token and fully removes your app from a customer's HubSpot account, including all associated features and webhooks. Upon a successful uninstall, super admins in the account will receive an email notification with a link to reinstall the app if needed.

Apps must use OAuth v3 endpoints

Effective immediately, all new app listings, certification submissions, and apps undergoing recertification, must use the new OAuth v3 endpoints.

OAuth v1 endpoints are being deprecated and will be replaced by the latest OAuth API endpoints, which are exposed in date-based versions:

• POST /oauth/2026-03/token - authorization code & refresh token exchange
• POST /oauth/2026-03/token/introspect - token introspection (access & refresh tokens)
• POST /oauth/2026-03/token/revoke - token revocation (refresh tokens)

Token access and storage security questionnaire

For certification and recertification, developers must now complete a security questionnaire*. This questionnaire will ask a series of questions regarding OAuth token access and storage. Key areas covered include: encryption, access controls, and token lifecycle management.

* The questionnaire extends beyond certification and will also be implemented for other programs, such as requesting access to sensitive data scopes.

Testing credentials no longer required for app listing

As of March 31, 2026, testing credentials no longer need to be provided for app listing submissions.

• This reduces partner effort and improves security by eliminating the need to share and store sensitive login information.
• Instead, demo videos or guided walkthroughs demonstrating core user flows, configuration, and permission usage should be provided.

See the updated marketplace listing requirements and certification requirements for more details.
If you have any questions or comments, please join the discussion in our community.

Original source

This month, on top of all the of the amazing updates and releases from Spring Spotlight 2026, we also have updates regarding the availability of our legacy CRM card migration tool, new features for the Custom Channels API, and more. Make sure to read on below for more details.

Legacy CRM Card Migration Tool Now Available

Starting April 21st, 2026, HubSpot introduced the Legacy CRM Card View Swapping Tool, which enables developers to migrate Legacy CRM Cards to UI Extension App Cards without disrupting existing customer CRM views.

Legacy CRM Cards are scheduled for deprecation on October 31st, 2026. Without migration, legacy CRM cards will eventually disappear from customer views that use them. The View Swapping Tool allows developers to proactively replace legacy cards with HubSpot’s newer App Cards while preserving existing view placements and minimizing customer impact.

The Legacy CRM Card View Swapping Tool is a developer-initiated migration workflow that:

• Replaces a legacy CRM card with a UI extension app card.
• Automatically updates existing customer CRM views.
• Requires no action from customers.
• Runs asynchronously across all app installs.

The migration with the swapping tool hides the legacy card and displays the replacement App Card in the same view locations.

What's changing?

New Capabilities

• A new migrate views API endpoint to replace legacy CRM cards with app cards in existing customer views.
• Support for the following view locations:
  • crm.record.sidebar
  • helpdesk.sidebar (explicitly required for ticket cards).
• Example App Cards, Postman Collection, and Figma design resources to accelerate migration.

Deprecation Reminder

Legacy CRM Cards will be fully deprecated on October 31st, 2026, and can no longer be created via the HubSpot UI.

Who Needs to Take Action

Developers should migrate if:

• Your app currently uses legacy CRM cards.
• Your app is installed in customer accounts where those cards appear in CRM views.
• You want to prevent customer-facing regressions when legacy cards are deprecated.

What does this mean for developers?

To begin migrating a legacy CRM card to an app card, follow the steps below or refer to this video demo.

Step 1: Prepare Your App

Upgrade to the latest HubSpot CLI version and connect to your HubSpot account:

npm i -g @hubspot/cli@latest
hs auth

Step 2: Migrate Your App

Ensure your Public (legacy) app is on the Projects Framework (Developer Platform version 2026.03+). If your app is not on the Project Framework, run:

hs app migrate

This migrates your app and existing legacy CRM cards without impacting customers.

Note: If you need additional references to migrate your app to the new framework, please refer to these guides:

• Migrate an existing public app to the projects framework

If your app is already project-based, run:

hs project migrate

Step 3: Create a Replacement App Card

Build a new UI extension app card to replace the legacy CRM card. There are two approaches depending on your goal:

• Option A: Redesign from scratch using the UI extension React components to take full advantage of the new framework’s capabilities. Figma resources are available for design support.
• Option B: Use the Legacy Card Converter for a quick migration that replicates your existing card’s behavior. Note that some differences apply, such as action requests using JSON instead of URL-encoded bodies and static card titles. See the README.md for more information.

Note: Develop and test App Cards in a separate testing app before deploying to production, as once view swapping has been initiated, it cannot be reversed.

Important migration notes

Ticket Support Considerations

If your legacy CRM card supports tickets, it’s important to note the following:

• Legacy cards automatically appear in the helpdesk.sidebar location.
• App cards do not.
• You must create two App Cards for each location, and each requires a unique title and extension card ID:
  • crm.record.sidebar
  • helpdesk.sidebar

Release the App Card

For migrated Marketplace apps:

• New app cards are hidden by default behind the hs-release-app-cards feature flag, which HubSpot auto-creates during migration and gates all app cards for each installed HubSpot account (you cannot gate individual cards).
• Use the hs-release-app-cards feature flag for testing and gradual rollout:
  • Turn it ON only for specific tests or beta portals by setting their portal-level flagState to ON while keeping other installs OFF.
  • To roll out to new installs only, batch-set all existing installs to OFF, then set the flag’s defaultState to ON so new installs automatically see app cards.
  • Expand access over time by switching additional portals to ON in batches until all installs are migrated.
• After rollout, delete the hs-release-app-cards feature flag so app cards are no longer gated.
• Before running the View Swapping Tool, confirm the flag has been deleted so replacement app cards are visible everywhere the migration will apply.

Note: To publish your app in the App Marketplace for the first time or to apply for certification if you already have a Marketplace-listed app, you must migrate and remove any legacy CRM cards and meet the Marketplace certification requirements and listing requirements.

Migrate Customer Views

Call the Migrate Views API once your replacement card is completed. Listed below are the required parameters:

• appId
• legacyCrmCardId
• appCardId
• helpdeskAppCardId (if applicable)
• Developer API key / OAuth token with sufficient permissions for the app.

This migration runs asynchronously across all installs. HubSpot will process the view updates asynchronously.

Example Response:

Migration Underway: X of X installs still processing

After the migration, the legacy CRM cards will no longer be visible and will be replaced by the app card. You can then safely remove the legacy card from your source code. If you do not remove it, the legacy CRM card will be automatically hidden from customers on October 31st, 2026, when the deprecation of legacy cards officially takes effect.

Note: End-user configuration is unnecessary. The existing card views will remain completely intact, ensuring that end-users experience no disruption, such as card loss or view resets, when your app card is implemented.

Standardized Memberships Error Messaging

Login failures for password-protected pages and memberships now return a single generic error message instead of multiple messages corresponding to the specific authentication issue.

What's changing?

Previously, Content Hub Professional and Content Hub Enterprise users could see different error messages depending on whether an email address existed or a password was incorrect. This created an inconsistent experience and could unintentionally expose account-related signals. This update improves security and delivers a more consistent login experience.

How it works

• All failed login attempts now return the same response, regardless of the underlying cause.
• Users will see a single message: “Invalid email or password.”
• No distinction is made between different authentication failures (e.g., incorrect email vs incorrect password)
• Existing login flows remain unchanged aside from this unified messaging.

This update is applied automatically, and no setup or migration is required.

Client Secret Rotation Now Available in Developer Platform UI

App owners can now rotate their app's client secret directly from the HubSpot developer platform UI with no support ticket required.

What's changing?

A new Rotate button now appears next to the client secret in the app's auth settings. Clicking it triggers a confirmation modal that requires you to type your app's name before proceeding. Once confirmed, the old secret is immediately invalidated, and a new one is generated.

Client secret rotation is available in:

• Legacy public apps: Developer portal > Auth tab
• Project-based apps: Projects > App Details > Client Credentials
• MCP Auth apps: MCP Connectors > Client Credentials

Why it matters

A leaked client secret can allow an attacker to create or generate OAuth tokens indefinitely. Previously, rotating a secret required opening a support ticket, a process that could take hours or days. This feature enables immediate, self-service response to security incidents.

Action required

No action is required at this time. If your app's client secret is compromised, you can now rotate it directly in your app's settings.

Custom Channels API: New sender and contact association options for outgoing messages

The Custom Channels API v2026-03 adds two new optional fields on outgoing messages: associateWithContactId and senderActorId. These fields give integrations more explicit control over which contact is linked to a thread and which actor is recorded as the sender of a message.

What's changing?

associateWithContactId

Channels using the CHANNEL_SPECIFIC_OPAQUE_ID delivery identifier type can now pass a HubSpot contact record ID when sending the first outgoing message of a thread via POST /conversations/custom-channels/2026-03/{channelId}/messages.

Example of associateWithContactId:

POST conversations/custom-channels/2026-03/123/messages
{
  "channelAccountId": 789,
  "messageDirection": "OUTGOING",
  "associateWithContactId": 54321
}

Constraints: only applies to CHANNEL_SPECIFIC_OPAQUE_ID channels; only takes effect on the first OUTGOING message of a thread; the contact ID is validated and must exist; requests on any other message type will be rejected. Channels using email or phone identifier types continue to resolve contact associations automatically.

senderActorId

All outgoing messages now accept an optional senderActorId field to record which actor (for example, a support rep, integration, or external chatbot) sent the message.

• Type: string
• Format: Conversations actor ID, such as:
  • A-12345 (HubSpot agent user)
  • I-67890 (integration)
• Scope: available across all delivery identifier types on outgoing messages.

When provided, senderActorId is used to attribute the message to that actor in Conversations (for example, which rep is shown as the sender). Example of a valid outgoing message with senderActorId:

POST conversations/custom-channels/2026-03/123/messages
{
  "channelAccountId": 789,
  "messageDirection": "OUTGOING",
  "text": "Hi from our support bot",
  "senders": [
    {
      "deliveryIdentifier": {
        "type": "CHANNEL_SPECIFIC_OPAQUE_ID",
        "value": "sender-opaque-id-123"
      },
      "name": "Support Bot",
      "senderActorId": "A-1234567"
    }
  ],
  "recipients": [
    {
      "deliveryIdentifier": {
        "type": "CHANNEL_SPECIFIC_OPAQUE_ID",
        "value": "recipient-opaque-id-456"
      }
    }
  ]
}

If senderActorId is missing, invalid, or used in the wrong context, the API returns HTTP 400 with a VALIDATION_ERROR response using the standard HubSpot error envelope. The most important cases are when using senderActorId on an INCOMING message. senderActorId is only allowed for outgoing messages. Including it on an INCOMING message will be rejected.

Personalized app and agent recommendations with Breeze Assistant

Users can now ask Breeze Assistant to recommend marketplace apps based on criteria entered, and refine the results with follow-up questions. Users can describe a business need in plain language and get pointed in the right direction, refining with follow-up questions until they land on the right fit, and find the right app faster and with confidence. See this product update for more details.

HubSpot CLI v8.4.0 Introduces Project Management Commands and UX Improvements

The latest HubSpot CLI version, 8.4.0, release adds two new commands, hs project info and hs project delete, enabling developers and AI agents to retrieve project metadata, generate install URLs, and delete apps directly from the CLI. The release also improves the developer experience with profile selection prompts when --profile is omitted and introduces an updated logging UI for supported terminals.

Several bugs have been addressed, including fixes for incorrect srcDir comparisons in hs project dev, improved profile error handling for 2025.1 projects, and issues affecting serverless function detection and local development.

For a complete list of available commands, check out the reference documentation.

Public Betas

Workflow action to change contact participant state for a marketing event

You can now automatically mark contacts’ participant state on manually created Marketing Events using a new workflow action.

With this workflow action, automatically mark contacts as:

• Registered
• Attended
• Canceled

Previously, businesses that relied on marketing events for lead generation and nurturing couldn't directly change contacts participation status for a marketing event. This update streamlines and automates that process. This workflow action is available for Pro+ customers. Learn more in the Product Update.

HubSpot IP Ranges Notifications

Introducing email notifications for HubSpot IP range changes. Customers can now subscribe to receive notifications when HubSpot’s published IP ranges are added, modified, or removed, allowing them to proactively update their firewall rules and network configurations.

Super admins can subscribe to email notifications via Settings → Notification Preferences → Security → IP Range Updates.

Questions or comments? Please join us in our developer forums.

Original source

Welcome to the Spring Spotlight special edition of the developer changelog.

We've got a lot of exciting updates to go over, including the general availability of date-based versioned APIs and Developer Platform version 2026.03. With these date-based updates comes a more stable release cadence. Both the APIs and Developer Platform project versions will have two major releases a year, in March and September. Additionally, to help you better prepare for these updates, we are also introducing an 18-month support cycle. Learn more about how date-based releases affect the Developer Platform

Developer Platform version 2026.03 now in General Availability

On March 30th, 2026, we released the HubSpot Developer Platform version 2026.03 for Projects, marking the first date-based platform version. This release reintroduced serverless functions to the Projects framework, formalizes an 18-month support lifecycle, and lays the groundwork for better alignment between the HubSpot Developer Platform, public APIs, and developer tooling.

If you’re currently building project-based private apps—especially those running on Projects version 2025.1—this release is your primary path to a modern platform with serverless support and predictable upgrade cadence.

What's changing?

Date-based platform version for Projects

Projects now support “platformVersion”: “2026.03” in hsprojects.json.

Each platform version follows a fix lifecycle:

• Current (6 months) - active maintenance, bug and security fixes.
• Supported (12 months) - critical fixes.
• After 18 months, versions become unsupported and are no longer updated; builds on unsupported versions will fail.

Serverless Functions on 2026.03

Platform version 2026.03 reintroduces serverless functions on the new Projects framework:

• Apps can define app functions using the updated *-hsmeta.json format (one function per file) instead of the single serverless.json file used in 2025.1, which was previously blocked from migrating to newer platform versions.

Agent tools on the Developer Platform

On the Developer Platform, you can build agent tools - enhanced custom workflow actions that HubSpot AI agents can call to perform tasks on behalf of users. Tools are implemented using the Developer Projects framework, submitted for review, and then made available to customers via your app listing and Breeze Agents.

Code Sharing for UI Extensions

You can now share code between UI extensions. Previously, if your App Cards, App Home Pages, and Settings pages required the same code types, utilities, and components, you had to copy the code for each instance. This meant that whenever you made updates, you had to revise every copy of that code separately.

New app listing & certification review updates

Staying on supported platform versions is now an expectation for listings and certifications. Marketplace apps that submit for listing/relisting or certification/recertification must run on a supported Developer Platform version (Projects 2025.2+ today, with 2026.03 as the recommended target), and certified apps must use a supported date-based API version. Additional app updates include:

• Classic legacy CRM cards must be migrated to App Cards by October 31, 2026. Effective immediately, legacy CRM cards are no longer permitted for new app listings, certifications, or recertifications. All listed or certified apps must migrate to App Cards or risk having their certifications revoked or delisted.
• Agent tools listing requirements for Marketplace apps. For apps that ship agent tools (like Breeze Agents can call), these tools are treated as a reviewable surface: they are built as enhanced custom workflow actions in a project. Marketplace-listed apps cannot deploy unapproved tools; deploys will fail until the tool passes review for compliance with the agent tool listing requirements.
• App Card Review Program reviews and approves CRM UI extension app cards submitted by Marketplace partners before they go live. Partners submit an intake form that includes their App ID, Build ID, and a video walkthrough, triggering an automated tracking ticket. A TPM reviews the video against four quality categories (security/privacy, performance/reliability, usability/accessibility, and value/functionality). Approval adds the app ID to the distribution list, and partners receive the Marketplace listing next steps.

Additionally, we’ll also be introducing a date-based version for APIs

Platform Projects version 2026.03 follows the same date-based naming convention as the public API date-based version /2026-03, improving clarity and consistency for developers building on HubSpot, without introducing technical dependencies between the platform and API date-based versions.

Key dates and next steps

• March 30th, 2026: Platform Projects version 2026.03 becomes generally available (first date-based platform version).
• August 1st, 2026: Projects version 2025.1 reaches the end of support; builds on 2025.1 will fail, and apps must move to 2025.2 or 2026.03 to stay supported.
• October 31st, 2026: Classic CRM cards sunset; apps must use App Cards on Projects 2025.2 or 2026.03 instead.

To get ready:

• Check your current platform version in the platformVersion field of hsproject.json, and plan your move to 2026.03 if you’re on 2025.1 or earlier.
• Review your UI extensions and migrate any classic CRM cards or legacy settings pages to App Cards, App Pages, and the new setting component model.
• If you build on the Marketplace, confirm your app is on the supported platform + API date-based version and review the App Card and agent tools listing requirements so you’re set up for future certifications and recertifications.

Helpful resources:

• Determine your migration path to 2026.03
• Serverless functions overview
• Agents and tools overview
• Share code between your extensions using npm workspaces
• Create an app card
• API versioning

Reintroducing Expanded Serverless Functions

Serverless Functions (App Functions) are back in the Developer Platform 2026.03. The Developer Platform 2026.03 release restores and expands the capabilities last seen in version 2025.1, aligning them with the unified Projects architecture introduced in 2025.02. A key update is expanded support for UI Extensions across App Settings and App Pages (formerly known as App Homes), including the ability to run and test functions in developer test accounts.

Availability and Access:

• App Functions (private)
  • Access: Requires an Enterprise subscription or a free developer test account.
  • Usage: Available within App Cards, App Pages, App Settings, and developer test accounts.
• Public Endpoint Functions
  • Access: Requires a Content Hub Enterprise subscription.
  • Usage: Public HTTP endpoints exposed via function configuration (for webhooks, public APIs, etc.).
  • Note: Public endpoints are not available in developer test accounts.

Functions can now run within Developer Test Accounts, enabling safer and more iterative development before production rollout.

How it Works:

• Upgrade to 2026.03: Ensure you are using CLI version 8.3.0 or higher, as the steps may vary based on your current version.
• From 2025.2: Update the platformVersion in your hsproject.json file from “2025.2” to “2026.03”, then run hs project upload.
• From 2023.0. 2023.2, or 2025.1: Run hs project migrate in your project directory and follow the prompts.
• Legacy public apps (non-project-based): Run hs app migrate and follow the prompts.
• Define your functions: Define serverless functions within your project directory, now aligning with the Projects 2025.2+ structure.
• Integrate with UI Extensions: Trigger these functions directly from the frontend code in App Settings and App Pages to handle custom data and enable user interactivity.
• Test in developer accounts: Deploy and validate your functions in a developer test account before deploying to production.

What's changing?

HubSpot offers multiple serverless function solutions depending on your use case:

Solution / Use Case / Access Level / Platform
2026.03 Serverless Functions — Modern project-based apps with UI Extensions — Private (App Functions) or Public (Endpoints) — HubSpot Projects
2025.1 Functions — Legacy project-based serverless functions — Private or Public — HubSpot Projects
CMS Serverless Functions — CMS Hub website functionality — Public endpoints only — CMS Hub

Key Differences:

• New configuration format: Uses -hsmeta.json files (e.g., myFunction-hsmeta.json) instead of a single serverless.json file. Each function has its own configuration file, improving validation and IDE support.
• Unified component model: Functions use the same Project schema as the other app components, making configuration more consistent across your app.
• Expanded UI Extension support: App Functions can be invoked from App Cards, App Pages, and App Settings, enabling richer in-app experiences powered by serverless logic.
• Simplified migration from 2025.2: If you’re already on 2025.2, moving to 2026.03 is primarily a version bump and reuse of the -hsmeta.json pattern your app already uses.

Configuration Examples:

Directory structure

Before (2025.1):

src/app/myFunctions.functions/
├── myFunction.js
└── serverless.json ← Single config for all functions

After (2026.03):

src/app/functions/
├── myFunction.js
├── myFunction-hsmeta.json ← Individual config per function
└── package.json

Configuration Schema

Before (2025.1):

{"runtime":"nodejs18.x","version":"1.0","functions":{"myFunction":{"file":"myFunction.js","secrets":["my_api_key"]}}}

After (2026.03):

{"uid":"myFunction","type":"app-function","config":{"entrypoint":"/app/functions/myFunction.js","secretKeys":["my_api_key"]}}

Functions are now configured and located in a single src/app/functions/ directory. This replaces the previous structure that used nested .functions folders. For complete migration steps, including updates from 2025.1 to 2025.2, please refer to the detailed guides in HubSpot’s Developer Documentation.

The 2026.03 version is now available. Developers can start building apps on 2026.03 or migrate eligible 2025.2, 2025.1, and 2023.3 projects to 2026.03.

Introducing a Modern API infrastructure: Date-based Versioned APIs

The first date-based API version, /2026-03/, is now available. Date-based versioning APIs from /2026-03/ onward use a /YYYY-MM/ format to clearly indicate the year and month they went live.

Why does it matter?

For included APIs, date-based versioning brings clearer expectations around timing of change with consistent windows for updates and support.

• Plan with confidence — breaking changes to supported APIs occur twice a year (March and September), with 18 months of support for each version.
• Reduce maintenance overhead — immutable API versions in /2026-03/ mean your supported APIs won't lead your integration to break unexpectedly within an API's support window, and you can migrate to newer versions on your own timeline.
• Navigate APIs more easily — Before, v1, v2, v3, v4 denoted versions of APIs. With date-based versioning, APIs from /2026-03/ onward will use a /YYYY-MM/ format to clearly indicate the year and month they went live.

How does it work?

Each version moves through three stages: Current (actively maintained, first 6 months), Supported (critical fixes to maintain stability and security, months 6–18), and Unsupported (no further updates after 18 months). Please note, HubSpot teams will continue to release enhancements via Public Betas throughout the year.

You can see which APIs are included in date-based versioning /2026-03/ here and HubSpot’s release schedule here.

Updates to the Webhooks Journal API

This release introduces several new capabilities to the Webhooks Journal API, including batched reads for higher-throughput journal processing, CRM object filtering on subscriptions to reduce event noise, list membership subscriptions for real-time list-change tracking, and a snapshot status polling endpoint to monitor asynchronous snapshot processing.

Webhooks Journal CRM Object Filtering (New)

The Webhooks Journal API now supports CRM-style object filtering on subscriptions, letting you define filter criteria (similar to CRM Search filters) that are evaluated against each journal event. Only events whose CRM object data matches your filters are written to the journal for that subscription.

This change reduces noise, bandwidth, and processing. It’s a push-based alternative to polling CRM APIs with the same filters, keeping your event selection logic centralized in subscription definitions rather than scattered across custom polling code.

Subscription Type for List Membership (New)

LIST_MEMBERSHIP subscriptionType lets your app receive your journal events whenever records enter or leave HubSpot lists, rather than polling the Lists API or inferring membership from property changes.

Webhooks v4 Batched Reads with Journal API (New)

The Webhooks Journal API now supports batched reads, allowing integrators to pull multiple journal entries in a single API call, significantly improving throughput for high-volume event streams and reducing per-entry request overhead.

Previously, the Webhooks Journal API required stepping through entries sequentially, meaning integrators had to make an API call for each journal entry URL and use a single “reader” process to advance the offset, which became a bottleneck at scale.

With this update, the Webhooks Journal API now lets you request multiple journal entries at once. Preserving the journal’s chronological, offset-based model while reducing the number of network round-trips required to stay caught up with event volume.

Batch Endpoints:

• Batch Read by offset: POST /webhooks/v4/journal/batch/read
• Batch Next (range from offset): GET webhooks/v4/journal/batch/{offset}/next/{count}
• Batch Fetch Earliest Entries: GET /webhooks/v4/journal/batch/earliest/{count}
• Batch Fetch Latest Entries: GET /webhooks/v4/journal/batch/latest/{count}

Note: Maximum batch size is 100 entries (journal batch operations), and exceeding the limit returns a 400 Bad Request error.

Snapshot Status Polling Endpoint (New)

You can now check the processing status of CRM object snapshots using a new polling endpoint. You can track whether a snapshot is still being processed, has completed successfully, or has failed. Each snapshot creation response now returns a snapshotStatusId that you can use to poll for updates until the snapshot reaches a terminal state.

Snapshot Endpoints:

• Create Snapshots: POST /webhooks/v4/snapshots/crm
• Check Snapshot Status: GET /webhooks/v4/snapshots/status/{statusId}

Note: 404’s are expected after creation. Status records are created asynchronously. This does not mean the snapshot failed - retry with backoff. Additionally, use an exponential backoff. Start at 1 second, cap at 30 seconds, and enforce a max polling direction (e.g., 10 minutes or 20 attempts) to avoid infinite loops.

For additional details on how to use the API, please refer to the developer documentation.

HubSpot MCP Server (remote) and Developer MCP Server (local) now in General Availability

The HubSpot MCP server (remote) is now generally available, enabling connecting agentic tools to your HubSpot account, and it includes expanded access. The HubSpot MCP server now has read-only access to campaigns, landing pages, website pages, blog posts. The HubSpot MCP server also has write access to CRM objects, meaning you can make updates to your CRM data through natural language.

Developers can use the HubSpot MCP server with AI APIs to build custom agentic workflows that leverage HubSpot data by building MCP auth apps.

The Developer MCP server (local) is also generally available, giving you the power to create HubSpot apps using natural language. You can download it through the HubSpot CLI and start chatting with it in your preferred AI-powered code editor, like Claude Code or Cursor. Run the command hs mcp setup to get started. You must be on the HubSpot CLI version 8.2.0 or higher to use the Developer MCP server. To check which version of the HubSpot CLI you're using, you can run the command hs --version.

The Developer MCP server has access to tools such as searching the developer documentaiton, creating new projects, and validating code before uploading to your account. See the table below for more info on the tools available:

Tool / Description
add-feature-to-project — Add a feature to an existing project
create-cms-function — Create a CMS serverless function
create-cms-module — Create a CMS module
create-cms-template — Create a CMS template
create-project — Create a new HubSpot project
create-test-account — Create a test account
deploy-project — Deploy a project
fetch-doc — Fetch documentation
get-api-usage-patterns-by-app-id — Get API usage patterns for an app
get-apps-info — Get apps information
get-build-logs — Get build logs
get-build-status — Get build status
get-cms-serverless-function-logs — Get CMS serverless function logs
get-feature-config-schema — Get feature config schema
guided-walkthrough-cli — Guided CLI walkthrough
list-cms-remote-contents — List CMS remote contents
list-cms-serverless-functions — List CMS serverless functions
search-docs — Search documentation
upload-project — Upload a project
validate-project — Validate a project

Expanding App Homes into App Pages, a Multi-page, Custom App Experience

App pages for UI extensions allows you to build custom, full-page experiences for your app directly within HubSpot using React. Starting with a dedicated app home as your app's landing page, app pages expand from there, letting you build as many additional pages as your app needs. Powered by UI extensions, these pages share the same toolkit as app cards and settings pages, allowing for a unified development approach that includes dedicated header actions, multi-page navigation, and seamless data fetching.

This feature fills a critical gap by providing a central home base for your app within HubSpot, eliminating the friction of sending users to external sites for dashboards, documentation, or configurations. App pages empowers developers to build a native-feeling, multi-page experience that improves user retention and gives users a dedicated, organized space for everything from high-level app interactions and reporting to onboarding flows and support resources.

Developers can get started by running hs project add in the CLI and selecting "Pages" to generate the necessary React and configuration files for their app pages. Additional pages can be added alongside it, with built-in PageRoutes and PageLink components handling navigation between them. You can build each interface using standard UI components and the PageHeader wrapper for primary and secondary page actions. Once deployed, users access app pages by clicking the Marketplace icon and selecting your app from "Recently visited apps" or via a direct app URL.

Keep your HubSpot Projects code DRY with code sharing

You can now share code across multiple UI extensions, app cards, settings pages, and app pages, within a single project using npm workspaces. You can create shared packages for utilities, types and components once, then import them into any extension in your project. With shared code, you can fix bugs in a single place, keeping things consistent between all pieces of your projects.

npm workspaces let you define shared packages for utilities, types, components or anything else alongside your extensions within the same project. Each extension can declare those shared packages as dependencies and import from them directly, just like any other package. Shared packages are installed automatically when you run hs project dev or hs project upload, or you can install them manually with hs project install-deps.

Technology Partner Program: Discover Your Tier in the New Dashboard

A new Technology Partner dashboard is now available in the Developer Platform, giving you an in-product view of your status in HubSpot's Technology Partner Program. From one place, you can see your current tier (Partner, Rising, Leading or Premier), what that tier unlocks, high-level requirements to maintain or advance and links to program resources and contacts.

Progress indicators show how close you are to the next tier based on key performance signals, refreshed approximately once per month. Tier badges also appear on your Marketplace app listing page and in Marketplace filters for Rising, Leading and Premier partners.

Public Betas

Connect the HubSpot MCP Server Securely with MCP Auth Apps

You can now build and manage your own AI connectors to the HubSpot MCP Server using a new self-service MCP Auth Apps tool in the Developer Platform. This update removes the need for general-purpose app tooling; it enables full lifecycle management of MCP connectors, including creation, configuration, and secure OAuth 2.1 credential access, all within a dedicated interface. End-user permissions are now handled automatically, giving customers more control over the data shared through MCP connections.

New App Install Governance Tool for Admins

Super Admins now have centralized control over which apps can be installed in their HubSpot account and what data can be shared with them — including controls over AI connectors like the HubSpot connectors for ChatGPT, Claude and Gemini.

With this public beta, admins can approve which apps are allowed, control which users can install each app, customize optional data permissions (such as read-only vs. write access) and revoke approval at any time.

Users who want access to an unapproved app can submit a request directly from within HubSpot for Super Admin review. Manage everything from Settings > Integrations > Connected Apps under the Manage Apps tab. Available across all hubs and tiers.

Learn more about managing app access

Original source

What's changing

The remote HubSpot MCP server is graduating from beta and is now generally available to all HubSpot accounts. This release adds write capabilities, engagement history, marketing content objects, and organizational context — so any MCP-compatible AI tool can now read from and write to your CRM through natural conversation, with your existing HubSpot permissions respected throughout.

The HubSpot MCP server connects any MCP-compatible AI tool to your CRM over a secure, HubSpot-hosted connection authenticated via OAuth 2.1 with PKCE. This release significantly expands what's accessible through that connection.

CRM objects and engagements now support full read and write access. Organizational context and marketing/content data are available as read-only:

• CRM objects (read/write): contacts, companies, deals, tickets, carts, products, orders, line items, invoices, quotes, subscriptions, and segments (lists)
• Engagements (read/write): calls, emails, meetings, notes, and tasks. Query engagement history alongside CRM records — for example, summarize the last three calls with a prospect, or create a follow-up task directly from your AI tool.
• Organizational context (read-only): users, teams, reporting structures, owners, roles, and seats
• Marketing and content (read-only): campaigns and campaign metrics, landing pages, website pages, and blog posts

A few things to keep in mind:

• OAuth 2.1 with PKCE is required for all connections.
• If your HubSpot account has sensitive data turned on, engagement objects (calls, emails, meetings, notes, and tasks) will be blocked from access through the MCP server. This restriction is specific to the MCP server and doesn't apply to the standard CRM APIs.
• All actions respect your existing HubSpot user permissions — users can only access or modify records they already have permission to view or edit.

If you already have the MCP server installed, your app may show a REQUIRES_REAUTHORIZATION status for newly added object types. To access the new scopes, disconnect and reconnect the app through your settings. You can check which objects and tools are available for your account by calling the get_user_details tool at the start of a session.

New to the MCP server? Getting connected takes three steps:

1. Create an MCP auth app. In your HubSpot account, go to Development > MCP Auth Apps and create a new app. HubSpot generates OAuth credentials automatically.
2. Create a managed OAuth connection. Connect any MCP client that supports OAuth with PKCE to https://mcp.hubspot.com using your app's client ID and secret.
3. Start prompting. Your AI tool can now query, create, and update HubSpot data using natural language.

For full setup instructions, including available tools and troubleshooting guidance, see the remote HubSpot MCP server documentation. Note that this server is separate from the developer MCP server, which is used for building apps and CMS content locally.

When is it happening?

This change goes into effect on April 13, 2026.

Questions or comments? Join us in the developer forums.

Original source

HubSpot will migrate content rendering from the legacy Java Runtime Environment (JRE) locale dataset to the Common Locale Data Repository (CLDR), the current industry standard for localization. Most content will remain unchanged, while some may see improved formatting accuracy.

What’s changing

All content rendered by HubSpot’s rendering services will transition from the legacy JRE locale dataset to CLDR. This impacts how locale-aware values including as dates, times, numbers, and currencies are formatted across:

• CMS pages
• Landing pages
• Blog posts
• Emails

This change enables more accurate and comprehensive localization aligned with modern internationalization standards.

Key formatting differences

CLDR introduces updated formatting rules that may result in subtle output differences:

• Non-breaking spaces (NBSP/NNBSP) may replace standard spaces in:
  • Time formats (between the time value and AM/PM marker)
  • Unit formats (between numeric values and unit labels)
  • Cyrillic date formats (before the year marker “г”)

These characters often appear visually identical to regular spaces but behave differently in code.

For additional technical background, see the Java documentation on CLDR locale data

Potential impact to existing implementations

Most content will not be affected. However, issues may occur if your implementation relies on exact string matching or parsing of formatted values:

• Code that compares formatted strings expecting regular spaces may fail
• Parsing logic that assumes standard whitespace may break silently

The following HubL filters are most likely to be impacted due to locale-aware formatting:

• datetimeformat: most affected (AM/PM spacing and Cyrillic formats)
• Timeformat: AM/PM spacing changes
• Numberformat: unit spacing changes

Review your usage of these filters if your implementation depends on exact string output.

For more details, see the HubL filter reference.

What do I need to do?

All rendering services will undergo this migration automatically. Unless your setup relies on specific string formatting, no action is needed. If you utilize the filters mentioned earlier, we recommend verifying that your implementation aligns with the updated standard.

Additionally, this upgrade enables support for modern Java features and improves overall runtime performance and internationalization (I18n) capabilities.

When is it happening?

This change goes into effect on July 14, 2026.

Questions or comments?

Join us in the developer forums.

Original source

Today we're introducing a new versioning system for our APIs, using a /YYYY-MM/ format (like /2026-03/) instead of v1, v2, v3, v4 to denote the month in which the API was shipped. This date-based versioning gives developers a predictable way to manage API updates and breaking changes.

Initially announced for CRM APIs for Fall Spotlight 2025, this has now been released for most recent versions of our APIs.

Why does it matter?

If you're a developer working with HubSpot APIs, you currently face unpredictable breaking changes, inconsistent version numbers across different APIs, and short deprecation windows that make it hard to plan updates.

With date-based versioning, you can:

• Plan with confidence - breaking changes only happen twice a year (March and September), and you get 18 months of support for each version instead of the previous 90-day minimum deprecation notice
• Reduce maintenance overhead - immutable API versions mean your integrations won't break unexpectedly, and you can migrate to newer versions on your own timeline
• Navigate APIs more easily - consistent date-based naming across all APIs replaces the confusing mix of v1, v2, v3, and v4 versions
• Leverage AI tools more effectively - the predictable pattern makes it easier for LLMs and AI agents to work with HubSpot APIs

For more background on why we're making these updates, and how these changes tie into the wider HubSpot Developer Platform, check out this blog post on date-based versioning.

How does it work?

Release schedule

New date-based API versions launch twice a year:

• March (e.g., /2026-03/) coinciding with Spring Spotlight
• September (e.g., /2026-09/) coinciding with INBOUND

Each version is immutable once released, receiving only critical bug fixes and security updates during a minimum support window of 18 months.

HubSpot teams can still release enhancements throughout the year via public betas. Beta APIs will be part of the next release. For example, with the release of /2026-03/, beta APIs will use version /2026-09-beta/.

Versions become unsupported after the 18 month support window. Unsupported versions may continue to function but are not guaranteed to get critical updates, and may not remain stable or available.

You can continue to use any supported version and migrate to newer versions on your own timeline, though we strongly recommend upgrading to the current version when a version becomes unsupported.

For more details about the release and support schedules see the versioning documentation.

What's included in /2026-03/

You can see which API's are included in /2026-03/ at https://developers.hubspot.com/docs/api-reference/latest/overview. These APIs are based on the latest v3 or v4 APIs, so if you were already using the latest version of an API you can update to the date-based version by updating the URL you are using.

The /2025-09/ CRM APIs announced at INBOUND 25 are still supported and will become unsupported with the release of /2027-03/.

Current v4 APIs will be supported until March 2027, and will become unsupported with the release of /2027-03/. Current v1-v3 APIs will continue to work as well, with the support timeline to be announced at a later date.

Questions or comments? Please let us know by joining the discussion in our community.

Original source

This month's rollup introduces exciting updates designed to streamline developer workflows and enhance visibility. Key highlights include the ability to view app objects directly within the Data Model Builder and a faster, video-based review process for App Cards. There are also three new public betas: a File Ingestion API for bringing raw tabular data into Data Studio, substantial feature enhancements and reliability fixes for the Conversations API, and a new Connection Insights tab to help you monitor app and integration activity at a glance.

Developer Updates for March 2026

New features for app objects: View in data model builder and add pipeline rules

To help you make the most of app objects, you can now view them in your data model builder alongside standard CRM objects and custom objects. This helps you understand how app objects interact and are associated with other CRM objects.

There are also three new pipeline rules for app objects. These rules can be configured individually in the app object’s settings:

• Limit record creation to specific stages
• Restrict records from skipping stages
• Restrict records from moving backwards

Adding pipeline rules ensures everyone in an account follows standard processes.

App card review updates

The App Card Review Program is being updated with an improved process for reviewing and approving CRM UI extension app cards submitted by marketplace partners before they go live. This updated process replaces a longer, more complex review with a standardized, video-based submission and evaluation.

The current process requires that a HubSpot review team be added as a super admin to a test account with the app card installed.

The updated process still begins with submitting the review form, but replaces the super admin manual review with an updated testing video review. The video must cover the complete functionality of the app card, as it will be reviewed against our updated quality categories and requirements.

This updated process will lead to more consistent feedback for partners, as well as a faster turnaround on marketplace applications. Please check the listing requirements and process documentation for more details as this new process is rolled out in the near future.

Public Betas

New file ingestion API beta for Data Studio

You can now use a new File Ingestion API that enables developers to upload static tabular data (CSV, XLS(X), TSV) as reusable data sources in HubSpot’s Data Studio. This API provides a developer-friendly, schema-agnostic way to bring structured data into HubSpot without mapping it to CRM objects.

What's new?

New endpoints:

• Create a data source: POST /data-studio/data-source/beta/
• Update (overwrite) a data source: PUT /data-studio/data-source/2026-9-beta/{datasourceId}
• Retrieve a data source: GET /data-studio/data-source/2026-9-beta/{datasourceId}
• Delete a data source: DELETE /data-studio/data-source/2026-9-beta/{datasourceId}

Key capabilities introduced:

• API-Driven File Imports: Upload CSV, XLS, XLSX, or TSV files (up to 512 MB) into Data Studio as named, reusable data sources.
• Schema-Agnostic Ingestion: Load raw tabular data without mapping to CRM objects.
• Flexible Column Typing: Define column data types explicitly using supported types:
  • STRING
  • INTEGER
  • DECIMAL
  • DATE (YYYY-MM-DD)
  • DATETIME (ISO 8601 format)
  • BOOL
• Overwrite-Based Updates: Update an existing file-based data source by uploading a new file.
  • The new file must include all existing fields.
  • Additional fields may be added.
  • Existing fields cannot be removed.
  • If no new configuration is provided, the existing schema is retained.
• Non-CRM Focus: This API is purpose-built for general datasets in Data Studio and is not tied directly to CRM object schemas.

What does this mean for developers?

Developers can now define a reusable external data source and programmatically manage it through the API.

To update data:

• Create a data source using POST /data-studio/v1/data-source
• Upload a new file via the versioned PUT endpoint to overwrite the existing data
• Ensure the updated file maintains schema compatibility.

All files uploaded to the same data source must maintain a consistent schema. Missing existing fields will cause the update request to be rejected. This API provides a dedicated pathway for managing non-CRM datasets in Data Studio and may serve as a forward-looking alternative to the Imports API for relevant use cases.

Note: Developers managing non-CRM datasets in Data Studio should use this API instead of (or alongside) the Imports API where appropriate. Ensure:

• Unique datasourceName values within the HubSpot Account
• Schema consistency across updates
• All required OAuth scopes are included.

Refer to the full API documentation for complete details on requests and responses.

Conversations API beta enhancements

The latest Conversations API (BETA) update includes several of your top-requested enhancements, important reliability fixes, and a Help Desk sunset reminder. Below is a complete breakdown of what’s changing, why it matters, and what developers can look forward to.

What's changing?

New Features:

• Assign or Unassign a User to a Thread: Developers now have direct access to assigning users to threads. This can be helpful if you have designed a bot to respond to messages, but need to hand the conversation off to a human.
  • PUT conversations/v3/conversations/threads/{threadId}/assignee
  • Accepts a JSON object with a single ‘actorId’ element in the request
  • DELETE conversations/v3/conversations/threads/{threadId}/assignee
• Identify what type of inbox: Inbox endpoints now include a type property to indicate whether a lowercase i inbox is a Conversations Inbox or a Help Desk:
  • Values are INBOX or HELP_DESK
  • Applies when resolving a lowercase i inboxId
• Check whether a thread is associated with a ticket: Thread endpoints now support explicitly requesting ticket association data:
  • New optional query param: association=TICKET
  • Available on the GET threads and the GET single thread endpoints
  • Responses may include a threadAssociations array with the associatedTicketId property

Retrieve all threads for a specific ticket:

You can now fetch threads associated with a given ticket:

• New optional query param on GET threads: associatedTicketId=12345
• Supports sorting by id and latestMessageTimestamp
• Enables common Help Desk workflows, such as “show all conversations for this ticket”.

New actor type: L (LLM): GET actor endpoints now expose actor type L (short for “LLM”), representing HubSpot’s Customer Agent.

Bug Fixes:

Several issues have been resolved to improve consistency and reliability across thread retrieval and messaging:

• threadStatus filtering now works reliably in all cases.
• Resolved inconsistent behavior when filtering by inboxId and sorting by latestMessageTimestamp.
• All threads now return when filtering by associatedContactId (previously only OPEN) and sorting by latestMessageTimestamp.
• Removed user-level permissions check that previously resulted in POST message requests to Help Desk Channels failing.
• Resolve the issue preventing the retrieval of more than 100 messages when timestamps were identical.

Sunset Reminder:

Help Desk is moving away from the legacy internal thread comments feature (shared with Conversations Inbox) and transitioning to Notes. As a result, posting and retrieving thread comments via the Conversations API will be sunset for Help Desk-connected channels. Developers should instead use:

• Notes API (to create/read notes)
• Associations API (to associate Notes with Tickets)

Important Note: Thread comments will continue to work for Conversations Inbox. For full details and timelines, see the dedicated sunset announcement here.

What does this mean for developers?

The Conversations API enables Smart CRM use cases such as exporting or archiving conversations, analyzing unstructured customer interactions with AI, mirroring Inbox or Help Desk conversations into external tools like Slack, supporting internal collaboration via comments or Notes, and powering translation workflows. Developers can discover inboxes and channels, retrieve and filter threads and messages, and post outbound messages and internal comments (Inbox only). For more information, please refer to HubSpot’s Developer Documentation.

Connections insights

Connection Insights is a new tab in Connected Apps that provides a high-level, centralized view of how your apps are behaving across HubSpot, at a glance. It brings together global insights about app activity, automation involvement, disconnect history, and API usage. From this tab, you can see:

• Automation insights: High-level signals that show how apps interact with automation, helping explain downstream behavior and linking you to relevant automation tools when needed.
• Record Insights: Get visibility into how your connected apps are interacting with CRM records by tracking record events (such as creates and updates) over time. Quickly understand which integrations are most active, how activity is trending, and which apps are driving the most changes in your CRM data.

This feature is currently in public beta. See the product notification for more details.

Questions or comments? Please join us in our developer forums.

Original source

We’ve added a confirmation dialog when HubSpot users install third-party apps that haven’t been reviewed by HubSpot’s Marketplace quality team. This helps users make informed decisions about connecting third-party apps to their accounts.

What’s changing?

When a user installs an unlisted or unverified app that hasn’t been reviewed by HubSpot’s Marketplace Ecosystem Quality team, HubSpot will now:

• Show a confirmation dialog before completing the installation.
• Ask for confirmation that you want to connect this unverified app to your account.
• Only proceed with the install after you confirm.

Please note that the install flow for Marketplace apps that are listed and approved remains unchanged. Private apps created for your own portals are also unaffected.

What does this mean for developers?

If your app is unlisted or unverified, users will now see this extra confirmation step. To help them feel confident approving the install, make sure your app name, description, and requested scopes clearly communicate what your app does and why it needs access.

If you haven’t already, please consider listing your app in the Marketplace and conducting a quality review to give your app users a smoother, more trusted install experience. This does not apply to Tech Partner Program members.

Questions or comments? Join us in the developer forum for a peer-to-peer discussion.

Original source

What’s changing

• Legacy developer accounts will be migrated to the unified Developer Platform. This experience consolidates developer tooling into a single HubSpot account and replaces legacy developer account structures.
• After migration, developers will manage apps, extensions, and integrations from one unified experience that supports the latest platform capabilities, including access to newer tools and programs.
• This upgrade enables you to:
  • Work from a single developer experience
    • Build and manage apps, UI extensions, and integrations from one HubSpot account.
  • Access newer platform features
    • New developer tools, app features, and the Tech Partner program are available only in the unified experience.
  • Reduce account complexity
    • Eliminate confusion caused by multiple developer account types and legacy tooling.
  • Receive improved platform support
    • Allows HubSpot to focus development and support efforts on a single, modern platform.
• Learn more about the unified Developer Platform and the migration process in the developer documentation:
  • Unified Developer Platform overview
  • Developer Platform migration guide

How it works

• The migration is designed to be seamless and does not require any manual steps to complete. After the upgrade, we recommend reviewing user access and administrative settings as part of post-migration setup.

Opt in early

• If you’d like to move to the unified Developer Platform ahead of your scheduled upgrade, you can opt in at any time by selecting
• Learn more
  • from the banner at the top of your Developer home page.

Automatic conversion

• If you do not opt in before your scheduled migration window, your legacy developer account will be automatically upgraded. No action is required to initiate the change.

Post-upgrade user access review

• After the upgrade, you’ll receive an email notification prompting you to review user access.
• You must confirm that the correct team members are assigned as
• Core Seat users with Super Admin privileges
  • (limited to two users), which helps avoid potential access issues. Users who have not been assigned a core seat will automatically be provisioned with a developer seat.

Grace period for updates

• You’ll have a two-week grace period following the upgrade to adjust administrative settings and user access as needed.
• We’ve also published a
• short walkthrough video
  • that explains what’s changing and what to expect after your account is upgraded:

When is it happening?

• The migration to the unified Developer Platform will roll out in phases.
• The rollout will begin on
• March 9, 2026
  -, with all legacy developer accounts expected to be migrated by
• March 31, 2026
  -.
• You’ll receive an email notification once your account has been upgraded.

Questions or comments?

• Join us in the
• developer forums

Original source

February updates from HubSpot

In February, HubSpot introduced a set of updates focused on improving developer visibility, extensibility, and platform flexibility. From enhanced OAuth install logging and Custom Events for Pro customers to deeper CRM associations and UI extension improvements, this month’s releases are designed to make building, managing, and scaling apps on HubSpot easier and more powerful.

Here are some important updates from February that affect external developers...

Code Sharing for UI Extensions

You can now share code between UI extensions. Previously, if your App Cards, App Homes, and Settings pages required the same code types, utilities, and components, you had to copy the code for each instance. This meant that whenever you made updates, you had to revise every copy of that code separately.

In the unified developer platform, your app cards, app homes, and setting pages are all part of the same app. With npm workspace support, your UI extensions can share the same codebase. Define your types once, write your API client once, and build a component library your whole project uses.

Associate Payments with Tickets

Payments can now be directly associated with tickets. In the UI, you can add a CRM card for Payments to the Tickets record page. Then, you can use this CRM card to directly connect the ticket you’re on to a Payment.

If you’re using the Tickets API endpoint for associations, you can use the HubSpot-defined associationTypeId of 1355. To associate a payment with a ticket, use the associationTypeId of 1354.

OAuth Install Event Logs

We’re adding OAuth install event logs to the Developer Platform, providing enhanced install visibility for all apps built on version 2025.2 or newer.

What’s new or changing?

• OAuth Install Event Logs: Developers can now track all OAuth app installation attempts, including whether an install succeeded and where failures occurred.

• Visibility into Install Flow: Logs will record key stages:

  • Install start (consent shown).
  • Install callback (user clicks Connect).
  • Token exchange (install completes).

• Filtering and Exporting: Logs can be filtered in the Developer Platform and exported via integrated observability tools or downloaded as CSV files.

This functionality is available for apps built on the Developer Platform v2025.2+. Please migrate your app if you wish to leverage install event logs. To access logs, go to Development > Monitoring > Logs in your HubSpot account. Set up observability integrations if you’d like logs exported automatically.

This change helps developers quickly identify and resolve installation issues and will improve the overall app install experience for customers using the Developer Platform.

Tech Partner Program Tiering

Technology Partner tiers help customers identify app developers who consistently deliver high-quality experiences in the HubSpot ecosystem. Tiers: Partner, Rising, Leading, and Premier are assigned at the developer level (not per app) and appear on Marketplace listings and filters.

Tier upgrades are evaluated quarterly based on performance over the previous 12 months, with downgrades beginning semiannually in 2027. Developers can track their current tier, progress toward the next level, customer value metrics, and influenced revenue in the Technology Partner dashboard, which updates monthly and is available to partners with an approved Marketplace listing using HubSpot developer tools.

To access the required Partner POC form (for Leading and Premier tiers), click Partner POC Form in the upper right of your dashboard.

To report closed deals or new accounts you influenced, click Submit influenced revenue and complete the form. See the Technology Partner Program Guide for details.

Connected Apps: New Connections Home & Connection Insights

Connections Home is a new centralized page for managing your integrations. It provides a comprehensive view of apps connected to your account, apps requiring immediate attention, and apps installed by other users across your organization.

This update also includes a new Connection Insights section that provides a detailed overview of app activities, Academy content, new API call usage, and new Record Insights that track how your apps interact with HubSpot and CRM data.

To view the new Connections Home, navigate to Settings > Integrations > Connected Apps. It includes three key sections:

• Needs Your Attention highlights app statuses and notifications, such as expired or disconnected connections, so you know what to fix first.
• My Apps displays all apps connected to your account, including connection status, install details, and recent activity.
• Other apps installed by users in my organization show all apps connected by users across the organization.

From the new Connection Insights page, you will find:

• App log & activities: View recent app activity, including connections, disconnections, and other key events, with filters for users and apps.

• Academy: Access relevant learning content to better understand and manage your connected apps.

• API call usage [new]: Track your daily API call usage across all private apps to monitor activity before reaching your limit, preventing disruptions caused by hitting API maximums. Note: API usage insights are also available within each individual app’s settings page.

• Record Insights [new]: This is a new section under Connection Insights that shows how apps are interacting with your CRM data. This includes daily record event counts broken down by app, which record types were affected, and the type of action taken (Created, Updated, Deleted, Merged). Note: Record insights are also available within each individual app’s settings page.

Custom Events Are Now Available to the Pro Platform

Custom events are now available to all Pro customers. Previously an Enterprise-only feature, Custom events let you track any behavioral data that matters to your business, such as product usage, purchasing behavior, offline interactions, third-party platform activity, and changes to properties inside HubSpot.

Note: Pro customers are limited to 10 million event occurrences per month. Enterprise customers are limited to 30 million event occurrences per month. Both Pro and Enterprise customers can define up to 500 distinct event types.

See the Knowledge Base article and product update for more details, and our Developer Documentation for instructions for using custom events.

Public Beta: Conversation & Workflows Ownership Updates

We’re introducing additional functionality to conversation-based workflows in Service Hub Professional and Enterprise subscription tiers in HubSpot Workflows & Inbox. These betas enhance ownership flexibility by adding a new “No Owner” option to the Assign Conversation Owner action and extending the Rotate record-to-owner action to work with conversations.

Together, these updates give support teams more structured, automated control over conversation routing and handoffs, while respecting inbox permissions.

What’s new or changing?

• New “No Owner” option (Assign Conversation Owner action)

  You can now automatically remove a conversation's owner via workflow. Previously, unassigning a conversation required manual updates or workarounds. With this update, workflows can clear ownership and return conversations to an unassigned state based on your defined criteria.

  How it works:

  • The Assign Conversation Owner action now displays a “No Owner” option at the top of the user list.
  • Selecting “No Owner” removes the current owner and returns the conversation to the inbox’s unassigned state.
  • This can be added to any conversation-based workflow.

• Rotate record to Owner is now available in conversation-based Workflows

  The existing Rotate Owner action has been extended to conversations. This action automatically moves a conversation to another inbox and assigns it to the appropriate user or team based on inbox access, bringing structured, automated handoffs (similar to CRM object rotation) to Service Hub conversations.

  How it works:

  Within conversation-based workflows:

  • Add rotate record to the owner from the CRM action list.
  • Select a target inbox (active, non–Help Desk inboxes only).
  • Choose your assignment method:
    • Customer Agent
    • Specific users or teams (with inbox access)
    • Contact owner (with fallback options)
    • No owner (to leave the conversation unassigned)
  • Configure availability settings (e.g., assign only to available users).
  • Save the action.

  Conversations enrolled in the workflow will be moved to the selected inbox and assigned based on your configuration.

  Note: Changing the assignment on closed conversations will reopen them. We recommend excluding closed conversations from enrollment criteria. If using rules-based bots, exclude bot-based chatflows from enrollment and use the Send to Team Member action inside the chatflow for routing instead.

  To get started, in your HubSpot account, click on Product Updates > search “Assign Conversation Owner Update — New “No Owner” and “Rotate Record to Owner action in Conversation-based Workflows”, and click “Join Beta” for each.

  Please refer to the linked documentation for additional information.

• Auto-Enrollment for Developer Platform Betas

  HubSpot is introducing a one-time “Join beta” opt-in that grants developers ongoing access to all current and future Developer Platform betas—no need to request access each time a new beta version ships. After enrolling and accepting the Beta Terms, you can build and deploy against a beta by referencing it in hsproject.json (for example, "version": "2026.03-beta"), and you’ll automatically stay enabled for future betas as they’re released. Learn more in the Product Update entry and review how platform versioning works in the docs: Product Updates and Platform Versioning.

Questions or comments? Join us in the Developer Community Forum for a peer-to-peer discussion.

Original source

What’s New

The HubSpot connector for ChatGPT can now create and update CRM records and log activities directly from ChatGPT’s chat window, including new contact and deal creation, and logging notes or tasks.

Additionally, You can also now access products, line items, invoices, orders, carts, segments (lists), and engagement history from calls, emails, meetings, tasks, and notes.

Watch Demo: Update your CRM with ChatGPT

Please note:

• If your HubSpot account has sensitive data enabled, the HubSpot connector for ChatGPT will not have access to any engagement data for added security.
• When using create and update actions in the HubSpot connector for ChatGPT, attribution will be recorded in your HubSpot account’s Audit Log to the user and the ChatGPT connector.
• The HubSpot connector for ChatGPT supports bulk Create and Update actions for a maximum of 10 records in a single request.

Why Does It Matter?

With expanded write access and engagement visibility, the HubSpot connector for ChatGPT allows you to update your HubSpot context directly without leaving ChatGPT. Ask ChatGPT to log a discovery call, create follow-up tasks, update deal stages, or analyze months of customer emails using natural language.

By accessing engagement history such as emails, tasks, and notes, ChatGPT can surface meaningful insights and let you take action on them instantly, right from the chat window. This unlocks faster, more intelligent use cases, like:

• Faster workflows: Create a task to follow up with a prospect who has questions on pricing.
• Smarter insights: ChatGPT can now access your email threads and call notes to provide context-aware recommendations.
• Less manual work: No more copying insights from ChatGPT into HubSpot properties manually – update directly from ChatGPT’s chat window.
• Better decisions: Analyze real customer conversations, not just CRM snapshots.

How Does It Work?

To access these new capabilities, you'll need to upgrade to the latest version of the HubSpot connector in ChatGPT. If you're setting up the HubSpot connector for the first time, review the setup steps here.

Watch: How to set up HubSpot app inside ChatGPT

Approve the updated app (ChatGPT admin required)

If you're a ChatGPT workspace admin, you'll see an "Enable the updated HubSpot app" pop-up when you open ChatGPT. Click "Enable for workspace" to approve it for all users.

You can also navigate to the HubSpot app from the ChatGPT App Directory and open it in Admin Console to enable it for your workspace.

Update the app (non-admin users)

After admin approval, individual users can upgrade the app:

1. In your ChatGPT chat window, click your profile icon in the bottom left.
2. Click Settings, then Apps, and select HubSpot.
3. In the upper right, click Upgrade.
4. Follow the prompts to re-authenticate the app.
5. When re-authenticating, make sure to select all necessary permissions to access write actions, newly added objects, and engagement history.

Using the HubSpot connector

1. In your ChatGPT window, click the + icon, then More.
2. Click HubSpot to enable the app. If your prompt includes the word "HubSpot," the app will turn on automatically.
3. Add your prompt and press Enter.

Example Prompts

Example Prompts

Updating CRM context (write access):
The HubSpot connector for ChatGPT can update your CRM directly.

• “Create a new contact for [X] at with their email [insert email address]”
• “Update the deal ‘Enterprise Package Q4’ to Closed Won.”
• “Log a note on this ticket summarizing our resolution approach.”
• “Create a task for me to follow up with [X] next Tuesday about contract renewal.”

Engagement visibility:
The HubSpot connector for ChatGPT can now access your communication history to provide richer context.

• Sales: “Summarize all my emails with [X] from the last month and list any issues that might affect deal closure.”
• Marketing: “Create Follow-Up Tasks from Recent Email Opens”
• Service: “Show me all open tasks assigned to me this week, sorted by priority.”

For more prompts, please visit our prompt library.

Additional Best Practices

• Start small by updating a single record before making bulk changes.
• Always review the proposed changes that ChatGPT shows before execution and take a moment to confirm them.
• For the best results, use the latest models.

Please note: A Super Admin or a user with App Marketplace permissions in your HubSpot account must connect the connector for the first time or, if already installed, uninstall and re-connect and select the allowed / updated permissions for it. Once this is done, they can give access to other users to connect it.
Learn more about how you can manage access to the connector.

The HubSpot connector for ChatGPT respects user permissions, users will only see the CRM context they’re allowed to access in HubSpot. For example, individual sales reps will only see pipeline data for deals they have permission to view or update.

The HubSpot connector for ChatGPT responds in the language used by the user, if supported. For the full list of supported languages, please refer to OpenAI’s multilingual documentation & supported countries and regions.

Who Gets It?

The HubSpot connector for ChatGPT is available to all HubSpot customers across all tiers with an OpenAI account.

Questions or comments?
Join us in the Developer forums.

Original source

The local HubSpot Developer MCP Server is now generally available, enabling developers to create apps and CMS assets through agentic tools like VS Code, Claude Code, Cursor, OpenAI Codex, Gemini CLI, and other MCP-compatible tools.

This local server connects agentic tools directly to HubSpot's developer platform, and empowers them with the context of HubSpot's developer documentation allowing developers to accomplish complex development tasks using natural language instead of having to manually parse docs, run CLI commands, or implement APIs.

Previously available as a beta, the general availability of the HubSpot Developer MCP Server brings full production support and stability to a workflow that's been proven across real development scenarios.

With this update, developers can:

• Build and iterate on apps — Scaffold, configure, and iterate on HubSpot apps without context-switching between tools.
• Create and manage CMS themes, templates and modules — Create and manage CMS assets like templates and modules directly from their AI tool.
• Manage serverless functions — Create, update, and troubleshoot HubSpot serverless functions through natural language prompts.
• Access app analytics — Query app performance and usage data conversationally to understand how integrations are performing.
• Troubleshoot with context — Debug and resolve issues faster with an AI assistant that has direct access to your HubSpot developer environment.

The HubSpot Developer MCP Server handles the repetitive, context-heavy parts of the development so you can spend more time building. For implementation details, see the developer documentation here.

When is it happening?

The Developer MCP Server is now generally available as of February 19, 2026, open to all developers building on the HubSpot platform.

Questions and comments?

Join us in the Developer forums.

Original source

Starting May 11, 2026

Starting May 11, 2026, HubSpot will resume the automatic migration of accounts from the legacy Cookie Consent Banner (v1) to the current version (v2). This process was previously announced and later paused to allow more time for manual adoption. This update ensures all accounts use a banner that meets modern accessibility standards and supports the latest privacy features. While the migration happens automatically on this date, you can manually opt-in ahead of time to test the new version within your account.

What's changing?

The v2 Cookie Consent Banner features an updated design, groups banners by domain, and includes features like support for Global Privacy Control (GPC), opt-out banner types, and expanded customization options.

This migration changes the HTML structure of the cookie banner. If you use custom CSS or JavaScript to modify your banner's appearance or behavior, you may need to update your code to remain compatible with the v2 structure.

Key considerations for developers:

• Updated HTML: You may want to review any CSS and JavaScript that previously targeted the cookie banner HTML because the HTML is changing.
• Refined styling: The v2 banner supports more customization options within the HubSpot UI, which may eliminate the need for some of your existing custom CSS. We encourage you to rely on the built-in customization options over custom CSS whenever possible to simplify future upgrades if privacy regulations change.
• Manual Testing: You can opt into the v2 migration manually in your banner settings to verify that your site's styling and scripts continue to function as expected before the automatic update.

When is it happening?

This change goes into effect on May 11, 2026.

Questions or comments?

Join us in the developer forums.

Original source