Hubspot Developers Release Notes

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

January’s developer updates focus on making HubSpot apps more flexible, scalable, and integration-friendly. Highlights include major improvements to UI Extensions, expanded API capabilities, enhanced sandbox and event management, Marketplace analytics upgrades, and new public betas that unlock deeper access to forecast and subscription data.

• UI Extensions: p_* wildcard enables cards for all custom objects
• Breeze Studio agents upgraded to GPT-5
• Sync Single Sign On (SSO) Settings to Sandbox and Developer Accounts
• Enhanced Quote Design with HTML Editing
• Custom events can now be deleted
• New Sandbox Listing Page
• Pre-rendering warnings now appear in Design Manager
• Breeze Customer Agent Now Supports Omnichannel Deployment via Custom Channels API
• New Campaign Asset Type Associations via Campaigns Public API
• Company Lifecycle Stage Properties
• Partner Search Analytics
• Marketplace Updates
• Custom event updates
• Public Beta: Forecast Read API
• Public Beta: Securely generate a preference page URL

UI Extensions
UI Extensions now supports a p_* wildcard in card configuration, letting you target all custom object types in a portal without listing individual schema names (like p_my_object) or portal-specific fully qualified names (like p123456_my_object). This removes a major blocker for public apps, since custom object names vary by customer portal—apps can now work across any customer’s custom objects without hardcoding object IDs. To use it, set the object target in your card config to p_* instead of a specific custom object name.

Breeze Studio agents upgraded to GPT-5
Breeze Studio agents now default to GPT-5 instead of GPT-4.1, including Marketplace agents like Deal Loss, Customer Health, Customer Handoff, and Social Post, as well as custom agents in private beta. Developers and customers should see improved reasoning and overall agent performance, with no action required for new agents. Existing agents created before December 1 have been automatically upgraded as of January 12, 2026—note that this change does not affect the Customer, Prospecting, or Data Agents.

Sync Single Sign On (SSO) Settings to Sandbox and Developer Accounts
When you enable Single Sign-On (SSO) on a production account, those settings now automatically carry over to any newly created Sandbox or Developer test accounts. This simplifies security setup and ensures non-production environments meet the same authentication standards without extra configuration.
Note that this does not retroactively apply to existing sandboxes created before SSO was enabled on production.

Enhanced Quote Design with HTML Editing
Commerce Hub quotes now support source code editing in the rich text editor, allowing users to view, edit, or directly write the underlying HTML. This unlocks advanced customization for quote templates, including custom layouts, branding styles, responsive content, and embedded assets that go beyond standard rich text controls. Template creators can now build quotes that behave more like modern web pages, eliminating fragile workarounds like image-based layouts.
How does it work?

• Going to Settings > Objects > Quotes > Quote Templates
• Within the Quote Template Editor, click into any content section
• Click Advanced > Source Code
• Edit the HTML and click “Save changes”
• Review the rendered content before publishing the quote template
  Quotes created from the quote template will automatically pull in the source code into the rich text sections. Source code cannot be edited at the quote-level.
  Learn more in the Commerce Hub Quotes documentation.

Custom events can now be deleted
You can now delete individual custom event occurrences directly from the Event Management tool, making it possible to clean up test events or incorrect data that previously couldn’t be removed. This helps keep reports, lists, workflows, and CRM records accurate and trustworthy. Deletions are available in-app only, support bulk deletes of up to 100 occurrences at a time, and are capped at 1,000 deleted events per month.

New Sandbox Listing Page
We’ve rolled out a redesigned Sandboxes listing page that centralizes sandbox management and production deployment tracking in a more intuitive layout. The update introduces a consolidated Sandboxes tab, a centralized activity log (covering sandbox creation details, deployments, and deletions with filtering by activity or user), and always-visible “Create a Sandbox” and “Set up a Deploy” CTAs at the top of the page. This improves information architecture and makes it faster to access sandboxes, review historical activity, and use deploy-to-production features. Availability is limited to users enrolled in the private or public beta for the new Standard Sandbox with improved production metadata and supported deploy-to-production assets.

Pre-rendering warnings now appear in Design Manager
To improve site speed, HubSpot automatically creates static versions of pages, blog posts, and knowledge base articles when possible. However, some HubL variables and functions are incompatible with pre-rendering. Before, you had to use ?hsDebugOnly=true.
Now, you can see warnings in the Design Manager about whether the page can be pre-rendered or not. Then, make changes to the code directly to address these warnings.
To opt-in to this feature, go into the Design Manager, open the Design Manager settings and toggle the Enable Pre-rendering Warnings on.

Breeze Customer Agent Now Supports Omnichannel Deployment via Custom Channels API
Breeze Customer Agent can now be deployed on ecosystem-built channel integrations, including SMS, Instagram, Telegram, LINE, WhatsApp, and Slack. Through the Custom Channels API, developers can integrate any messaging channel to Help Desk or Conversations Inbox. Customer Agent now works on any Custom Channels API channel.
What does this mean for developers?
Developers’ messaging integrations gain a powerful AI feature that makes them more valuable to customers, and any existing integration is ready to go, with no code changes necessary.
Sales and Service Hub Professional and Enterprise customers can deploy Customer Agent to custom channels.
This means your integrations can now do the following:

• The ability to assign Customer Agent to a custom channel from either the Customer Agent or channel connection setup user flows.
• Adjust customer agent handoff behavior.
• The Customer Agent responds to incoming queries on your channel.
  Note: If you are installing new channels into your existing Marketplace apps and customers have previously installed the app, you may need to ask them to re-authorize the app to grant it access to the Custom Channels API scopes.
  To get started, please refer to the documentation and explore which Marketplace app offers this functionality out of the box.

New Campaign Asset Type Associations via Campaigns Public API
We are enhancing the Campaigns API to support associations with an expanded range of campaign asset types. Developers can now programmatically add, list, or remove 11 additional asset types to campaigns, mirroring what’s possible within the HubSpot platform.
What's new?
You can now associate the following asset types with a campaign via the API:

• Ads (AD_CAMPAIGN)
• Blog Posts (BLOG_POST)
• Files (FILE_MANAGER_FILE)
• Landing Pages (LANDING_PAGE)
• Marketing Email (MARKETING_EMAIL)
• Marketing Events (MARKETING_EVENT)
• SMS (MARKETING_SMS)
• Social Posts (SOCIAL_BROADCAST)
• Video (MEDIA)
• Website Pages (SITE_PAGE)
• Workflows (AUTOMATION_PLATFORM_FLOW)
  These asset types are supported by the following API endpoints:
• Add Asset Association
• List Assets
• Remove Asset Associations
  Note: Previously, these types had to be managed via the HubSpot platform, with only a subset available through the API.
  Developers can begin reviewing and updating integrations if using custom apps or workflows to manage HubSpot campaigns, using the required asset types.
  Example payload for asset association:

{"campaignGuid":"your-campaign-guid-here","assetType":"MARKETING_EMAIL","assetId":"your-asset-id-here"}

Please refer to the developer documentation for full endpoint details.

Company Lifecycle Stage Properties
Each lifecycle stage now has four new company properties that track the company's progression through its lifecycle:

• Date entered stage
• Date exited stage
• Latest time in stage
• Cumulative time in stage
  These properties help you understand how companies move through your sales process. These company properties are automatically created for each lifecycle stage including any custom lifecycle stages created in an account.

Partner Search Analytics
App partners now have access to search analytics! This lets you track how marketplace searches enable discovery in the HubSpot Marketplace, including key metrics like:

• How often your app appears in search results (impressions)
• Which search terms lead to clicks on your listing
• Ranking position for each term (1 = top result)
  You can now monitor trends over time to understand how listing updates affect visibility.
  You can see search analytics right in your developer account under the app’s Marketplace Analytics.

Marketplace Updates
We have two quick updates for managing your app marketplace listings.
We've migrated autotranslate to our unified marketplace platform, fixing recent bugs, and improving the submission experience + end customer translations. If you already have translated listings (manually or automatically created), you won't see any changes - this update enhances reliability and streamlines new submissions.
This update will mean more reliable translations, and the autotranslate checkbox will be pre-selected, making it quicker and easier to get better translations for your listing.
We are also increasing the limit for review responses in the HubSpot Marketplace from 1 to 2. This will allow you to create 2 responses for any reviews, one to acknowledge the issue and one to notify the customer that the issue has been fixed.

Custom event updates
We have several updates for custom and app events.
Custom events created via webhooks often capture key integration data from across your tech stack, and until now, these events weren't shown in the activity timeline, didn't have the same property options as other custom events, and couldn't be edited after creation. Now, webhook Custom events function like other custom events. When a rep opens a record, they can now see any event triggered via webhook—without leaving HubSpot or running a report.
Custom events now supports the importing of event data to backfill historical data, integrate data from your tech stack with HubSpot, or capture offline behaviors you want to represent as events in HubSpot. Previously, imports could only be done as a separate, standalone event type. Now, when choosing import, you can import data to an existing event type. Additionally, imports previously only supported contact based events. Events can now be created via import for any object type Custom events supports.
We've updated the event management page to make it possible to dismiss errors for custom events. Previously, Custom event errors stay on the main event management page for 30 days, regardless of whether the issue has been resolved. Now, you can dismiss the error badge to no longer be notified about this issue for this event.
Finally, custom events and app events can be linked to several additional object types. Previously, app events and custom events could only be linked to Contacts, Companies, Deals, Tickets, and Custom objects. Both event types can now be linked to Leads, Projects, Services, Orders, Courses, Listings, and Appointments.

Public Beta: Forecast Read API
We’re excited to announce the BETA release of our Forecast Read API, available to Sales Hub/Service Hub Professional and above. This new API enables customers to access their forecast submissions from HubSpot in a structured, queryable, and read-only format—ideal for Business Intelligence (BI) reporting, analytics, and integration into data warehouses. With this release, customers can now self-serve and programmatically retrieve forecast data, advancing data accessibility and integration capabilities.
What's changing?

• Read-only API access to all HubSpot forecasts, no UI changes required.
• Structured data retrieval: Query specific fields and integrate results into BI tools or data warehouses.
• Integration-ready: Use your authenticated app (crm.objects.forecasts.read scope) to access data programmatically.
• No UI/UX changes are required: Usage is fully programmatic through the API, and there are no changes to your HubSpot account via the forecast tool.
• Beta program: This feature is in BETA. By participating, you agree to HubSpot’s Developer Terms and Beta Terms. Functionality and endpoints are subject to further development and changes.
  Usage
  Authorize your app with the crm.objects.forecasts.read and the oauth scope to use the endpoint. Below are the listed new read-only endpoints:
  Get all forecasts:
  GET /crm/objects/v3/forecasts?properties=property1,property2
  Get by ID:
  GET /crm/objects/v3/forecasts/{id}
  Example response:

{"results":[{"id":"475911884905","properties":{"hs_created_by_user_id":"2620022","hs_createdate":"2025-10-10T19:42:51.001Z","hs_lastmodifieddate":"2025-10-14T16:52:43.757Z","hs_milestone":"monthly","hs_object_id":"475911884905","hs_team_id":"39577840","hs_year":"2025"},"createdAt":"2025-10-10T19:42:51.001Z","updatedAt":"2025-10-14T16:52:43.757Z","archived":false}]}

For more details, please refer to the HubSpot API Developer Documentation.

Public Beta: Securely generate a preference page URL
The Preference Link Generation endpoints allow you to generate secure URLs to the Manage Preferences and Unsubscribe pages for any contact in your HubSpot CRM. This will allow your contacts to manage their email preferences directly from account settings or other authenticated areas of your website without requiring them to re-enter their email or dig up a past marketing email.
We've added to our Subscriptions Public APIs v4 so that you can call the new POST /communication-preferences/v4/links/generate endpoint with a contact’s email (subscriberIdString), optional language, and (for a single unsubscribe) a subscriptionId. You’ll receive secure, contact-specific links to:

• Manage Preferences page
• Unsubscribe from All page
• Unsubscribe from a Single Subscription Type page
  For more information on how it works refer to the developer documentation.

Join the discussion in the Developer Community.

Original source

What’s Changing?

New Oauth v3 Token Endpoints

To align with OAuth 2.0 security best practices, we have introduced two new v3 OAuth API endpoints designed to keep sensitive credentials out of server logs and browser histories.

• POST /v3/token: Handles authorization code and refresh token requests.
• POST /v3/introspect: Performs token introspection, replacing the separate v1 path-based token metadata for access tokens and refresh tokens.

Standardized OAuth Error Responses

We are updating our OAuth error responses to comply with RFC 6749. This ensures better compatibility with third-party OAuth libraries and simplifies troubleshooting.

What’s changed?

Previously, responses included HubSpot-specific fields (status and message). Responses now include the standard error and error_description fields.

Example Response:

// Example Response
{
  "error": "invalid_grant",
  "error_description": "refresh token is invalid, expired or revoked",
  "status": "BAD_REFRESH_TOKEN",
  "message": "refresh token is invalid, expired or revoked"
}

Existing fields (status, message) remain for backward compatibility, so existing error handling will continue to function as is.

Important Note: These responses will be reflected in both the v1 and v3 OAuth API endpoints.

What does this mean for developers?

• Adopt v3: Start targeting /v3/token and /v3/introspect for all new developments.
• Update Request Logic: Ensure your application sends credentials in the request body, never in the URL.
• Error Handling: You can now update your client-side error handling to parse standard OAuth error fields.

Important note: There are no changes to the scope, app settings, or the OAuth install process.

Sunset Notice for v1 OAuth API Endpoints

The v1 OAuth API endpoints will remain operational for now, but they are officially deprecated. We will provide a detailed sunset timeline later in Q1 2026. Please subscribe to the HubSpot Developer Changelog to ensure you receive this update.

When is it happening?

The v3 OAuth API endpoints are now available for use, and the error standardization is now reflected in both the v3 and v1 OAuth API endpoints.

Questions or comments?

Join us in the developer forums for a peer-to-peer discussion.

Original source

What’s changing

HubSpot CLI v8.0.0 is a major release focused on maintenance and cleanup. It removes long-deprecated functionality and aligns the CLI with previously announced platform changes.

Node.js requirements

• The minimum supported Node.js version is now Node 20
• Legacy behavior for hs theme preview on Node versions lower than 20 has been removed

This follows prior guidance:

• In April 2025, we announced an October target for deprecating Node 18 in all serverless functions and the CLI

Deprecated commands removed

Commands deprecated in favor of the newer hs cms, hs app, and updated command structure have now been fully removed. This follows the command reorganization announced in October 2025.

Removed command Replacement command hs create hs cms app hs fetch hs cms fetch hs function deploy hs cms function deploy hs function list hs cms function list hs function server hs cms function server hs lint hs cms lint hs list hs cms list hs logs hs cms function logs hs module marketplace-validate hs cms module marketplace-validate hs mv hs cms mv hs remove hs cms delete hs theme generate-selectors hs cms theme generate-selectors hs theme marketplace-validate hs cms theme marketplace-validate hs theme preview hs cms theme preview hs upload hs cms upload hs watch hs cms watch

Custom object schema command changes

The following legacy commands have been removed in favor of updated equivalents:

Removed command Replacement command hs custom-object schema create hs custom-object create-schema hs custom-object schema delete hs custom-object delete-schema hs custom-object schema fetch-all hs custom-object fetch-all-schemas hs custom-object schema fetch hs custom-object fetch-schema hs custom-object schema list hs custom-object list-schemas hs custom-object schema update hs custom-object update-schema

Additional breaking changes

• Removed support for 2023.2 projects
  • Creating 2023.2 projects via hs project create is no longer supported
  • Migrating legacy apps to 2023.2 using hs app migrate is no longer supported
• Removed deprecated command:
  • hs project clone-app
• Removed support for the HUBSPOT_PORTAL_ID environment variable
  • Use HUBSPOT_ACCOUNT_ID instead

Bug fixes and improvements

• Fixed an issue where CLI versions > 7.9.0 did not work with the --use-env flag
• General refactoring and cleanup tied to deprecated functionality removal

For full release details, see the GitHub release notes:
https://github.com/HubSpot/hubspot-cli/releases/tag/8.0.0

CI/CD considerations

This release does not force an immediate upgrade to HubSpot CLI v8.0.0. However, CI/CD pipelines may be affected once this version is adopted.

In particular, we recommend reviewing the following in automated environments:

• Environment variables
  • Replace usage of the deprecated HUBSPOT_PORTAL_ID environment variable with HUBSPOT_ACCOUNT_ID
  • This variable is commonly set in CI/CD workflows and is no longer supported in v8.0.0
• GitHub Actions
  • If you are using version 1 of the HubSpot CMS Deploy GitHub Action, upgrade to v1.8
  • Earlier versions install the latest version of the HubSpot CLI, which may pick up breaking changes
  • Version 1.8 pins installation to the latest v7 CLI release to avoid unexpected breaks
• CLI command usage
  • Review pipeline scripts for deprecated or removed CLI commands
  • Update command references to their supported replacements before adopting v8.0.0

When is it happening?

This change goes into effect on February 9, 2026.

Questions or comments?

Join us in the developer forums.

Original source

Ecosystem partners and customers can now build and manage their own AI connectors to the (Beta) HubSpot Remote MCP (Model Context Protocol) Server through a streamlined self-service interface. This public beta builds on the initial release of the HubSpot Remote MCP Server and simplifies the experience of creating and managing AI connectors directly.

What’s Changing?

A new MCP Auth Apps UI has been added to the HubSpot Developer Platform to allow ecosystem partners and customers to build and manage their own AI connectors to the HubSpot Remote MCP Server through a streamlined and fully self-service experience.

An earlier public beta, released on September 1, 2025, introduced the HubSpot Remote MCP Server available across all hubs and tiers. However, connector creation and management still relied on other platform developer tools intended for apps providing more functionality in HubSpot.

With this update, partners and customers can independently manage the full connector lifecycle using the new UI, including:

• A dedicated MCP Auth Apps section in the HubSpot Developer Platform
• Creating new MCP connectors through a self-service interface
• Modifying and maintaining connector settings through the UI
• Securely access their OAuth 2.1 credentials for integrating external systems with the HubSpot Remote MCP Server

End-user installation permissions for these apps are now managed automatically, giving customers full control over what HubSpot data they share via the MCP server connection without requiring partners to manually configure or manage permissions.

For implementation details, see the developer documentation.

When is it happening?

• The initial public beta for the HubSpot Remote MCP Server went live on September 1, 2025.
• A new public beta for self-service connector creation and management using the MCP Auth Apps UI for ecosystem partners and customers went live on January 13, 2026.

Questions or comments? Join us in the developer forums.

Original source