Hubspot Developers Updates & Release Notes

What's Changing

At Fall Spotlight on September 15, HubSpot is announcing the end of support for v1-v3 APIs, legacy public apps, and legacy private apps, all with a September 2027 enforcement date. If your integration or app uses any of these, you have a 12-month window to migrate.

This changelog covers v1-v3. Support for v4 is ending on its own separate timeline, March 30, 2027, which was announced earlier this year. See the previously published v4 changelog for that timeline.

This post covers breaking changes only. For everything new and non-breaking in this release, including the APIs reaching general availability, the updated APIs, the new public betas, and the latest AI builder tools, see the Fall Spotlight 2026 developer rollup.

Three simultaneous announcements share the same enforcement date: September 2027.

1. API versions v1-v3 are going unsupported

Endpoints using numbered version paths, /v1/, /v2/, and /v3/, will move to unsupported status. HubSpot will no longer release bug fixes, reliability improvements, or security updates for these versions. After September 2027, these endpoints will be unsupported. (Support for v4 is ending separately on March 30, 2027, announced earlier this year. See the v4 support timeline.)

Migrate directly from any legacy version to date-based versioning (DBV). Do not use v3 or v4 as an intermediate step. See the DBV migration guide for the full process, including endpoints where the response shape changes, not just the URL path.

2. Legacy public apps are going unsupported

Public apps created before June 23, 2026 use HubSpot's pre-Projects app architecture. These apps move to unsupported status on September 15, with enforcement in September 2027. To remain listed in the Marketplace and retain certification, migrate to the current Projects-based app model. See the app migration guide.

3. Legacy private apps must migrate

Private apps built before the Projects-based private app model was introduced must also migrate to Projects-based private apps by September 2027. This is a separate announcement from the public app change.

If you're building a new private integration, use Service Keys (now available) instead of creating a new legacy private app. Service Keys are the recommended path for lightweight integrations, internal tools, and AI agent integrations, with no full OAuth backend required. See the Service Keys documentation.

Note: legacy private app creation is disabled on September 28, 2026 for new accounts and October 26, 2026 for existing accounts.

For marketplace apps: two compliance requirements

Apps in the HubSpot Marketplace must meet both requirements to remain listed and retain certification. They apply independently, so you need to address both.

• Using unsupported API versions (v1-v4) after September 2027: your app loses its certification status.
• Running on legacy app architecture (pre-Projects) after September 2027: your app is eligible for delisting.

An app that has migrated to Projects but still calls v1-v4 APIs is still at risk of losing certification. An app using date-based APIs but still on legacy app architecture is still at risk of delisting.

How to prepare

1. Check which APIs your apps use.
   Starting September 15, the developer home tasks card shows "X of your apps use APIs becoming unsupported" and links to the migrations tab. Note: detection checks API calls at runtime, not your source code. Runtime calls to legacy endpoints will be flagged even if your codebase has been updated.

2. Check your app architecture.
   Go to your Developer Home or Projects list to confirm whether your apps are Projects-based or legacy.

3. Check your private apps.
   If you have any private apps created before the Projects-based private app model, those also need to migrate.

4. Migrate using the guides.
   The DBV migration guide covers API versioning. The app migration guide covers app architecture.

5. Watch the developer changelog for endpoint documentation.
   Not all legacy replacement paths are finalized yet. The March 2027 DBV release will include full per-endpoint replacement documentation for every legacy API. You have until September 2027, so plan your timeline accordingly.

When is it happening?

Date Milestone
September 15, 2026 All three changes announced; 12-month migration window opens
September 28, 2026 Legacy private app creation ends for new accounts
October 26, 2026 Legacy private app creation ends for existing accounts
September 2027 Enforcement; legacy APIs unsupported, legacy public apps and private apps also unsupported

Starting September 15, the developer home tasks card is the fastest way to see your specific impact. Migration guides are available for API versioning and app architecture.

Questions? Join the migration discussion in the developer forums.

Original source

Developer Platform Version 2026.09 Updates

General Availability of Projects Version 2026.09

Projects version 2026.09 is now generally available, and is the second date-based release for the platform, with an 18-month support window. This release includes the following features:

• User-level apps (general available): apps that act on behalf of specific users, enforcing that user's exact HubSpot permissions at runtime.
• Service keys (public beta): the replacement for legacy private apps with scoped API access for in-account integrations with better security defaults, permission scoping, built-in activity logging, and key rotation.

To create user-level apps, declare isUserLevel: true in your app configuration. When users authenticate via OAuth during app install, permissions will be scoped according to the user's CRM access at runtime.

To create service keys, navigate to Settings > Integrations > Service Keys to create scoped API credentials without needing a full project-based app.

Additionally, a new UI extension, app actions, is now in public beta. App actions let users perform custom operations on one or more selected CRM records directly from the CRM records list pages. When a user selects one or more records and triggers your action, HubSpot renders your custom React component, as a modal or panel, with the selected record IDs and object type available in the extension context.

To get started with the new version, update the platformVersion field in your hsproject.json files to 2026.09.

Connected Apps: Redesigned App Overview & App Owner Management

The Connected Apps surface has been redesigned and now includes formal App Ownership, giving admins clear accountability over every integration in their portal.

Redesigned app overview
Each app now has a tabbed settings page instead of a single long page. Tabs: Overview (feature cards or marketplace listing), Insights (Activities, Events Records, Automation, Academy), and Settings. The Insights tab is the main addition for developers — Activities logs installs, uninstalls, permission events, and ownership changes; Events Records shows record-level activity your app is driving; Automation shows workflow usage powered by the app.

App Owner
Every connected app now has a formal owner, set automatically to the installer. Admins with install/uninstall permissions can reassign via the Manage link in the App Info panel. All ownership changes are written to the Activity Log alongside install and uninstall events.

Deactivation awareness
When a HubSpot user is deactivated, the flow now warns if they are the owner, installer, or authenticated user for any connected app. Admins can reassign before completing deactivation.

Create Custom Events without linking to an Object

Custom events no longer require an object record and can now be created using "No Object" (via webhook or API) for the Agentic automation builder.

This enables immediate automated routing through HubSpot for external or stack-wide signals, such as:

• Product releases or hotfix deploys (notifying CSMs)
• BI report completions (emailing stakeholders)
• Weather alerts (alerting field technicians)
• External signals like FDA approvals, federal contract awards, or news paired with an RSS feed and webhook forwarder (routing info to reps)

Objectless custom events can be used in Automation and managed alongside other events in Event Management (Data Management → Event Management).

Generally Available (GA) APIs in 2026.09

Conversations API

The Conversations API is now generally available. It gives developers programmatic read/write access to HubSpot's Conversations Inbox and Help Desk (inboxes, channels, threads, and messages). Until now, most of this data was locked inside HubSpot's UI. With the API, you can pipe conversation data into external analytics tools, mirror threads into Slack or Teams, build AI workflows on top of unstructured message history, create custom routing and assignment logic, and archive conversations to meet compliance requirements. Authenticate with conversations.read and/or conversations.write scopes to list inboxes, retrieve connected channels, fetch and filter threads, update status and assignments, and read or send messages including internal comments. The API also supports webhooks for real-time events: thread creation, deletion, status changes, assignment changes, and new messages.

The API now supports user-level auth, allowing integrations to perform thread, message, and inbox operations on behalf of specific authenticated users based on their assigned permissions.

Price Books API

The Price Books API is now generally available for Commerce Hub Professional and Enterprise accounts. Until now, customers building CPQ integrations had no way to manage price books through an API. This had to be done manually in-app.

This API supports full CRUD on price books, lifecycle operations (activate, deactivate, validate), and per-item CRUD plus batch add, update, and archive on price book items. Price book and price book item records are also accessible as read-only objects via the CRM API, including list, batch read, and search.

Authenticate with cpq.price_books.read and/or cpq.price_books.write and/or crm.objects.products.read scopes.

Payment Links API

You can now programmatically create, retrieve, and manage HubSpot Payment Links via an API, including support for dynamic multi-item carts and custom configurations.

To create a payment link, send a POST request to the Payment Links endpoint with required parameters, including line items, quantities, discount codes, and customer information.

Additionally, the API supports dynamic configuration for defining items, add-ons, buyer email, billing/shipping address, and custom fields in the request. You can also deactivate or manage existing payment links as needed.

Payments Account Read API

The Payments Account Read API is now generally available. It gives partners and integrators a read-only way to check the payments readiness of any HubSpot account programmatically — previously there was no way to verify this without manual intervention, which made it hard to build payments-aware workflows.

Send a GET request to /commerce/payment-accounts/2026-09/payment-accounts with the PAYMENTS_READ scope to retrieve an account's enrollment status, payments eligibility, and transaction capabilities. Use it to gate payments-related features in your app on whether a portal is actually set up to collect and pay out.

Available to any account with HubSpot Payments enabled.

Pipeline Rules API

The Pipeline Rules API is now generally available, closing a long-standing parity gap in HubSpot's pipeline functionality. Until now, pipeline rules could only be configured in the UI.

The API lets developers manage CRM pipeline rules programmatically: which stages objects can be created in, which stages allow backward movement, whether stages can be skipped, and which stages require approval. This gives partners and advanced customers a way to enforce consistent pipeline governance across portals from their own external tooling.

Available for Professional and Enterprise tiers across all hubs.

Object Tags API

The Object Tags API is now generally available. Object tags are colored labels automatically applied to records that match criteria you define, for example a "Large deal" tag on any deal over $10,000. Until now they could only be configured in the UI.

The API supports full CRUD on object tag definitions. Send a POST to /crm/object-tags/2026-09/{objectTypeId} with a name, color, filter criteria, and the pipeline IDs the tag applies to (leave empty to apply across all of the object's pipelines); read, update (PATCH / PUT), and delete are all supported. Tags apply to objects that use pipelines, such as deals and tickets. This closes a known parity gap in HubSpot's pipeline functionality.

Available for Sales Hub and Service Hub Starter and up, and Smart CRM Professional and up.

Task Series API

You can now create and manage repeating tasks through the API. Previously, making a task repeat as a series required the UI.

The API adds support for creating tasks that repeat as a series and editing the future occurrences in that series, bringing an important piece of task functionality to the platform for the first time.

Available for Sales Hub and Service Hub Starter, Professional, and Enterprise.

Forecasts API

The Forecasts API is now generally available. It gives you read-only programmatic access to the forecast data your team submits in HubSpot's forecast tool, so you can pull it into BI tools, data warehouses, and reporting workflows.

Three read endpoints are available on the 2026-09 version:

• Retrieve forecast submissions: GET /crm/objects/2026-09/forecasts (filter by properties like amount, milestone, pipeline, team, and year)
• Retrieve submission history as events: GET /forecast-submissions/2026-09/events (chronological submission changes, with amount deltas)
• Retrieve forecast types: GET /forecasting-settings/2026-09/forecast-types (including custom types and deal-split configurations)

Authenticate with the crm.objects.forecasts.read scope. Available for Sales Hub and Service Hub Professional and Enterprise.

Notetaker Conversation Recap API

The Notetaker Conversation Recap API is now generally available. It gives you read-only access to the AI-generated summaries and action items that HubSpot's Notetaker produces after a recorded call or meeting, in a structured, queryable format you can pull into BI tools, data warehouses, and automation workflows.

Make a GET request to /notetaker/2026-09/conversation/recap/{objectTypeId}/{objectId} (use 0-48 for calls or 0-47 for meeting events). The response returns a summary object and an actionItems object, each with a status field (SUCCEEDED, NOT_FOUND, IN_PROGRESS, or FAILED) — check the status before reading values, since recap data is only available once Notetaker finishes processing the activity. Action items include a title and assignee.

Authenticate with the crm.objects.contacts.read scope. Available for Sales Hub and Service Hub Professional and Enterprise.

Teams API

The Teams API is now generally available. Until now, the API only supported listing teams. Creating, updating, and deleting them required the UI. With the new API you can create, rename, delete, and organize teams, plus manage membership.

User API - Seat Management

Seat management is now available in the User API (/settings/users). A new GET /seats endpoint lets you list available seat types on the account. The user provision (POST), update (PUT), and response (GET) models now include a seatNames field, so you can assign, update, and read seat assignments in the same calls you're already making to manage users. Viewing available seats requires the seats scope; assigning or removing seats requires the settings.billing.write scope.

Sequences API Expanded

The Sequences API has been expanded to allow users to perform writable CRUD operations, including:

• Creating sequences
• Retrieving specific sequences
• Updating sequences
• Deleting sequences

Previously, you could only use the API to enroll contacts into a sequence. This API requires user-level authorization for full functionality.

Email Template API

Email Templates are now accessible via API, letting you create and manage templates programmatically instead of through the UI.

The API covers: list templates, list folders, get a template, create a template, update a template.

Auth note: This API requires user-level authorization. Portal-level apps will see inconsistent results. Configure your app for user-level access before integrating. See the user-level access guide.

Datasource Ingestion API for Data Studio

You can now programmatically manage data in HubSpot Data Studio. Currently, two data source types are supported:

• FILE — upload a CSV, XLS, XLSX, or TSV file to create a data source
• JSON — define a schema and push structured data directly via API, with an incremental data-push endpoint for ongoing updates

Unlike the CRM Imports API, which has strict data requirements, the Datasource Ingestion API is schema-agnostic. Data doesn't need to map to any HubSpot object type. You define the schema, ingest data via file upload or JSON, and it lands in Data Studio immediately available for datasets, reports, and activation across segments, workflows, and lists.

The data-push endpoint enables lightweight, ongoing ingestion for recurring data updates such as partner enrichment feeds, operational snapshots, or agent-generated outputs, without managing file uploads each time.

File Manager API

Privately distributed apps can now download sensitive file attachments directly from the FileManager API using a file ID. Send a GET request to /v3/files/{fileId}/download. For sensitive files, your private app must have the FILE_MANAGER_SENSITIVE_ACCESS scope. Non-sensitive files don't require it. If authorized and the file exists, the endpoint streams the file bytes as a direct download.

Updated APIs in 2026.09

The 2026-09 release updated 44 existing APIs. Nearly all are version-parity updates — the same endpoints, now available on the stable 2026-09 version — so if you pin to a version, update your path to 2026-09. The updates that added real capability (Sequences, Files, User Provisioning/Seat Management) are covered as full entries above; the complete list of updated APIs is below.

New Beta APIs in 2026.09

The 2026-09 release includes APIs in public beta — usable now.

• Lead Scoring Public API
• Contracts API
• AEO Public API
• Marketing Forms API
• Automation Workflows API
• Scheduler API
• Subscriptions Lifecycle API
• Activity Auto Associations via Public API

Build with AI Updates

Build with AI content on Dev Docs

A new Build with AI section is now live in the HubSpot developer documentation. It's a dedicated resource for those who want to use AI tools to build on HubSpot, covering how to get set up, what tools are available (AI connectors, MCP server, Agent CLI, and Breeze Assistant etc), best practices, and example prompts to get you moving quickly.

The section is designed to meet you where you are. If you're a less technical builder excited about AI but not sure where to start, these docs provide a clear path in. If you're a more experienced developer, the best practices and tool breakdown give you a solid reference for how HubSpot's AI building surface fits together.

Find it under the Build with AI tab on developers.hubspot.com.

Developer Docs AI Assistant - Skills Upgrade

The AI assistant on our developer docs has never been more helpful. We've upgraded it with numerous skills that make it better for helping you find information, troubleshoot, and make decisions around which tools to use for what. The assistant helps walk you through troubleshooting rate limits, navigate authentication methods and scopes, API versions, HubSpot's AI related development tools. The assistant is even better at assisting with debugging and helping you structure feedback back to HubSpot. While using the Developer MCP server is still the best way to get help with your code because your coding agent knows your codebase, the assistant is there to help out before you're even at that point.

HubSpot MCP Server & Claude Connector Updates

The HubSpot MCP server and the Claude connector expanded significantly this release — both in what data they can reach and in what they can do with it. AI tools and agents can now work across far more of your CRM, and, for the first time, configure the data model itself.

Expanded data access
Custom objects, activable objects, and the Leads object are now supported for both read and write. Custom objects (any 2-* type) are readable and writable, so analyses are no longer limited to HubSpot's default object model — the AI can work with the domain-specific objects and custom fields your team actually built. The activable objects are now covered too: Leads, Appointments, Projects, Listings, Services, Courses, and Orders/Carts. That enables workflows like creating a custom object record from a meeting transcript, adding a lead from a conversation, spinning up a project from a call, or converting an abandoned cart to an order — all in one conversation, with the write landing in HubSpot.

Alongside those objects, the MCP server added new capability areas:

• Leads — read access, including partner client access
• Landing pages & content analytics — create and update landing pages; view conversion, submission, and view data for landing pages, website pages, and blog posts
• Campaign management & attribution — create campaigns, associate assets, and access revenue and deal attribution
• Marketing email — create drafts, configure send details, schedule, publish, and access post-send analytics
• Quotes & revenue objects (public beta) — create and manage quotes; read contracts, subscriptions, invoices, payments, and payment links
• Conversations — read-only access across Help Desk and Conversations inboxes, including live chat, team email, WhatsApp, SMS, Facebook Messenger, and custom channels
• Conditional property rules — the server now respects conditional field logic when creating or updating records
• Verified domain restrictions — Claude Enterprise admins can restrict connector access to company-provisioned accounts

Configuration
The MCP server now exposes HubSpot's configuration layer, not just its data. AI agents and developer tools can create and manage custom properties and set up pipelines and stages without leaving the AI workflow — so analysis and configuration can happen in the same conversation. Because this operates on your data model, it runs inside HubSpot's existing controls: every write is attributed in the Audit Log, and actions respect the acting user's permissions.

To pick up the new objects and scopes, reauthenticate your HubSpot connection. Landing page and content analytics tools surface automatically with no action needed.

Expose Your App's Tools in HubSpot Agents with an MCP Server Component

You can now add an mcp-server component to an existing app to expose your own remote MCP server tools inside HubSpot Agents. Once your app is installed, customers get access to your tools through Agent Builder automatically — no separate setup on their end.

To get started, add an mcp-server component using the HubSpot CLI and set platformVersion to 2026.09 in your project config. Both private apps and marketplace-distributed apps are supported; marketplace apps require HubSpot review and approval before broader release.

Build agents in Breeze Assistant

Breeze Assistant now guides you through building inside Agent Builder, available in public beta.

Until now, building a custom agent meant starting from a blank canvas: you had to know which tools to configure, how to structure instructions, and where your data lived before anything could run. Breeze Assistant removes that barrier.

Open Agent Builder from Agent Hub, select Create, and describe what you want your agent to do in plain language: for example, "Qualify every new contact against our ICP criteria before a rep sees them." Breeze Assistant proposes a configuration including goal, tools, and knowledge sources drawn from your portal. It may ask clarifying questions to refine the setup, then opens the configured agent in Agent Builder ready to test or publish. Breeze Assistant remains available in the sidebar throughout: ask it to adjust instructions, swap tools, or generate custom code for automation steps at any point.

Breeze Assistant is available across all hubs and tiers. Agent Hub and Agent Builder require Professional or Enterprise.

Original source

August’s developer updates expand how teams bring data into HubSpot and automate CRM operations. This month introduces webhook data sources for Data Studio, preserves active workflow enrollments when records are merged, and adds app object support to association workflow actions. Together, these changes reduce custom integration work and help automations continue with less manual intervention.

Join the discussion in the Developer Community.

• Stream JSON data into Data Studio with webhook data sources
• Primary records remain enrolled in workflows after merges
• Manage app object associations with workflows

Stream JSON data into Data Studio with webhook data sources

Developers and app partners can now send real-time JSON data from any HTTP-capable system directly into HubSpot Data Studio, without file uploads or a custom connector. Each source provides a unique inbound URL and supports GET, POST, and PUT requests, with options to create records or update existing records using a match key. Requests are currently limited to one record each, and the inbound URL should be treated as a secret because it is the source’s only authentication mechanism. Once ingested, the data can be used in datasets, segments, workflows, and reports; learn more about building and activating datasets in Data Studio.

Primary records remain enrolled in workflows after merges

When two CRM records are merged, the primary record will remain enrolled in its active workflows, preserving its current position, delays, branches, and pending actions. Only the duplicate record being merged away will be unenrolled, allowing data cleanup without interrupting in-flight automation. This change applies automatically to all CRM object types that support merging, and no action is required. Learn more about merging records in HubSpot.

Manage app object associations with workflows

The Manage CRM record associations workflow action now supports app objects from connected apps, allowing workflows to create, update, or remove associations between app object records and other CRM records. This eliminates manual linking and custom automation while making it easier to incorporate app data into existing pipeline, attribution, segmentation, and reporting processes.

Original source

What's Changing

HubSpot is permanently removing the ability to create new legacy, non-Project based, private apps through the account UI. Users needing similar functionality should use Service Keys, available via Developer Platform Projects version 2026.09 or later, which supports system-to-system integrations. This sunset impacts customer accounts on two timelines based on their age. All existing legacy private apps are not affected at this time.

Starting in late September 2026, the option to create new legacy private apps will be removed from the HubSpot account UI. The rollout is tiered by account age:

• New HubSpot accounts (created on or after September 28, 2026): Legacy private app creation is disabled on September 28, 2026
• Existing HubSpot accounts (created before September 28, 2026): Legacy private app creation is disabled on October 26, 2026

What is not changing:

All existing legacy private apps continue to work as-is. This change only removes the ability to create new ones. Now is your chance to get ahead and migrate existing legacy private apps to the Developer Platform Projects framework. Build on a more modern foundation and be ready for what’s next.

For any new in-account API integration, use Service Keys, HubSpot's modern authentication solution now available. Create a Service Key at Settings > Integrations > Service Keys.

Service Keys provide:

• Scoped access: grant only the permissions your integration needs
• Built-in activity logging: audit trails out of the box
• Easy key rotation: 7-day grace period for safe credential rollover
• Admin-only key visibility: key values restricted to admins by default

For integrations that require the use of webhooks, please see our “Create an app” guide for more information about how to use our new platform tools to support this use case.

When is it happening?

This change goes into effect on September 28, 2026 for accounts created on or after that date, and on October 26, 2026 for accounts created before that date.

Questions or comments? Join us in the developer forums.

Original source

Node 18.x and 20.x are being deprecated as supported runtimes for Chatflows custom code snippets. If you have bot code snippets running on either of these versions, you need to upgrade them to Node 24.x before August 31st, 2026, or you will lose the ability to edit those snippets until the upgrade is completed.

What's Changing

Node 18.x and 20.x have reached end of life and no longer receive security patches. To keep Chatflows custom code snippets on a secure, maintained foundation, HubSpot is deprecating support for these runtimes in favor of Node 24.x, the current long-term support (LTS) release.

To make upgrading easier, you can now change the Node.js runtime version of an existing bot code snippet in-place, without deleting and recreating the snippet. In the bot snippet editor, look for the option to change the runtime version. Your code, environment variables, and configuration are preserved through the switch. This capability is rolling out gradually over the next 2 weeks.

After August 31st, 2026, any snippet still running on Node 18.x or 20.x will become read-only. You won't be able to edit it until you upgrade the runtime to a supported version.

When Is It Happening?

Upgrade your Chatflow bot code snippets to Node 24.x before August 31st, 2026. After that date, snippets on unsupported runtimes will be locked from editing until upgraded. The in-place runtime switching feature is rolling out to Data Hub Professional and Enterprise customers now.

Questions or comments? Join us in the developer forums.

Original source

Starting with the /2026-09/ API version shipping on September 8, 2026, HubSpot will enforce admin-configured validation rules on all CRM API write paths. If your integration creates or updates CRM records, please make sure that it conforms to the below changes before updating your version of the API.

What's Changing

When a HubSpot admin configures rules governing how records are created or modified (conditional required properties, required fields on the Create Record form, or user-level association permissions), those rules will now apply to API writes, not just actions taken in the HubSpot UI. While this is a breaking change in that you will get error messages, these changes exist to help your app avoid making changes that violate HubSpot user's expectations which could put their data into strange states that run contrary to their rules.

Three behaviors are being enforced:

Conditional required properties. If an admin has configured a rule that makes a property required when another property has a specific value (for example, close_date becomes required when dealstage is set to closedwon), the API will return a 400 validation error if that property is missing on write. Previously, these rules were UI-only and the API ignored them.

//Example of an error

{
  "category": "VALIDATION_ERROR",
  "message": "...",
  "errors": [
    {
      "code": "MISSING_CONDITIONAL_REQUIRED_PROPERTY",
      "message": "my_property is required because of a conditional property rule based on [country]",
      "context": {
        "propertyName": [
          "my_property"
        ]
      }
    }
  ]
}

Record creator settings. If an admin has marked specific properties or associations as required at record creation time in Settings → Objects → [Object Type] → Create Record, the API will enforce those requirements on POST calls.

//Example of an error

{
  "status": "error",
  "category": "VALIDATION_ERROR",
  "message": "The property values provided are invalid",
  "errors": [
    {
      "code": "MISSING_REQUIRED_PROPERTY",
      "message": "A value for firstname must be provided",
      "context": {
        "propertyName": [
          "firstname"
        ]
      }
    }
  ]
}

Edit Associations permission. If your app uses user-level OAuth and the installing user does not have the "Edit Associations" permission (CRM_ASSOCIATIONS_WRITE_ACCESS scope), API calls that create, update, or delete associations will return an error. This does not affect portal-level app tokens.

//Example of an error

{
  "status": "error",
  "message": "Missing 'Edit Associations' permission.",
  "category": "VALIDATION_ERROR"
}

These behaviors only apply when an admin has actively configured these rules on a portal. If no conditional required property rules, record creator requirements, or association permission restrictions exist on a portal, there is no behavior change.

How to prepare

1. Suggest users of your integration to review the account your app writes to. Check Settings → Properties for conditional required rules, Settings → Objects → [Object] → Create Record for required field settings, and Settings → Users & Teams to confirm your app's installing user has the appropriate permissions.
2. Fetch current property definitions via GET /crm/{version}/properties/{objectType} to identify required fields before your write calls.
3. Ensure your write calls include all conditionally required properties when the controlling property value is set.
4. Ensure POST calls to create records include all properties and associations marked as required in Create Record settings.
5. If your app uses user-level OAuth, confirm the installing user has "Edit Associations" enabled, or remove association writes from your app's scope if not needed.

Handling validation errors

When enforcement is active, API write calls may return 400 Bad Request if the request violates an admin-configured rule. These errors indicate that the portal's configuration requires something your request didn't include, not necessarily a problem with your integration's logic.

• Parse the error message. Each violation returns a specific message identifying the rule that was violated (e.g., "Property 'close_date' is required when 'dealstage' is set to 'closedwon'." or "Missing 'Edit Associations' permission.").
• Re-check portal configuration. The rule may have been added or changed by an admin after your integration was last configured. Poll GET /crm/v3/properties/{objectType} to detect changes to required fields.
• Retry with corrected input. Adjust your request to satisfy the rule and retry. Do not retry the same request unchanged.
• Surface actionable errors to your users. Translate the validation message into guidance they can act on (e.g., "This portal requires a Close Date when Deal Stage is Closed Won").

Datetime validation improvements

The CRM API now handles datetime property inputs more permissively. Previously, valid inputs like off-midnight date values, ISO-8601 strings, or epoch-second timestamps could be rejected with errors like INVALID_DATE or cryptic range messages. The API now normalizes these inputs and returns a successful response with a new warnings array on the response object that describes any normalization that occurred. Error messages for genuine failures have also been improved to include the raw input, the parsed interpretation, and which constraint was violated.

If you want to surface normalization notices to users, read the warnings field from write responses. If your integration is expecting a certain shape to the error message, confirm that it is updated to this new shape.

//Example

{
  "category": "PROPERTY_VALUE_NORMALIZED",
  "context": {
    "normalizedValue": "631152000000",
    "propertyName": "date_of_birth",
    "rawValue": "1990-01-01T00:00:00Z"
  },
  "message": "date_of_birth was normalized"
}

When is it happening?

Enforcement goes into effect on September 8, 2026, with the release of the /2026-09/ API version. To learn more about HubSpot's date-based API versioning and how to migrate, see the Date-Based Versioning guide.

Questions or comments?

Join us in the developer forums.

Original source

Increase owner property limit to 250

HubSpot now supports up to 250 owner properties per object type, up from the previous limit of 50. This gives teams with more complex assignment and ownership tracking needs more flexibility without requiring support requests or workarounds.

Increase Webhooks Journal batch size to 10,000 records

HubSpot is increasing the Webhooks Journal batch size from batches of 100 records per S3 file to up to 10,000 or 5MB (whichever comes first). This increase is specific to the number of journal events contained within the returned S3 Presigned URL. This will increase speed efficiency when working with the Webhooks Journal.

This update will not affect the Webhooks Journal API limits.

Historical API Usage Chart

Historical API Usage is now available in Connected apps, giving customers a clearer view of where their API calls are coming from across apps and connectors. In Connected apps > Connection insights > API Call Usage, teams can review historical usage trends to better understand activity patterns, plan ahead, and make adjustments as needed.

Public betas

Contract Imports

Contract Imports is now in public beta, allowing customers to bring active contracts from external systems into HubSpot using the import tool. Customers can upload contract data by CSV, including key contract properties, contacts, line items, and deal associations, then manage those imported contracts in HubSpot with the same workflows used for contracts created natively, including change quotes and renewal quotes.

See the Contract Imports product update for more details and to join the beta to test this feature.

Payment Links API

You can now programmatically create, retrieve, and manage HubSpot Payment Links via the API, including support for dynamic multi-item carts and custom configurations. The Payment Links API beta has the following endpoints:

• POST /commerce/payment-links/2026-09-beta/payment-links
• GET /commerce/payment-links/2026-09-beta/payment-links/{paymentLinkId}
• GET /commerce/payment-links/2026-09-beta/payment-links
• PATCH /commerce/payment-links/2026-09-beta/payment-links/{paymentLinkId}
• DELETE /commerce/payment-links/2026-09-beta/payment-links/{paymentLinkId}

To learn more about these endpoints, check out the developer documentation.

Questions or comments? Join us in the developer forums.

Original source

7/23/2026 Edit

The post has been updated to include the Deal object specific validateDealStageUsagesBeforeDelete query parameter.

Availability: This is a breaking change for the next GA date-based API version, /2026-09/. It does not change the behavior of the current GA API version or earlier versions. Integrations will see this behavior only after moving to /2026-09/ or later.

Learn more about HubSpot's Date Based Versioning

What is changing?

Starting in version /2026-09/ of the Pipelines API, HubSpot will validate references before deleting a pipeline or pipeline stage. If the pipeline or stage is in use, the delete request will be blocked and return a validation error.

This makes public API deletes behave the same way as deletes from the pipeline settings page in HubSpot, where deleting a pipeline or stage is already blocked when it is in use.

The reference check is enabled by default because validateReferencesBeforeDelete and validateDealStageUsagesBeforeDelete will default to true in /2026-09/.

validateDealStageUsagesBeforeDelete is used for the Deal object and validateReferencesBeforeDelete for all other object types.

To bypass this validation, pass:

validateReferencesBeforeDelete=false
validateDealStageUsageBeforeDelete=false

Affected endpoints

• DELETE /crm/pipelines/{version}/{objectType}/{pipelineId}
• DELETE /crm/pipelines/{version}/{objectType}/{pipelineId}/stages/{stageId}
• PATCH /crm/pipelines/[version]/({objectType})/({pipelineId})
• PUT /crm/pipelines/[version]/({objectType})/({pipelineId})

This change applies when {version} is /2026-09/ or a later DBV version.

Why does this matter?

This change makes pipeline deletion behavior consistent between the HubSpot UI and the public API, and helps prevent accidental deletion of pipelines or stages that are still referenced by existing objects.

Integrations that currently rely on deleting in-use pipelines or stages may receive a 400 validation error after upgrading to /2026-09/. To preserve the previous behavior, explicitly set validateReferencesBeforeDelete=false, or validateDealStageUsagesBeforeDelete, or remain on an earlier version until you are ready to migrate.

Migration guidance

Before upgrading to /2026-09/, review any integration logic that deletes pipelines or pipeline stages. If your integration expects deletes to succeed even when a pipeline or stage is in use, update the request to pass false to the above mentioned query parameters. Otherwise, handle the new validation error and prompt users to remove references before retrying the delete.

Question or comments?

Join us in the community

Original source

June’s developer updates include new CRM and customer success signals, cleaner subscription-status histories, expanded Knowledge Vault support for structured data, app object activity association controls, quote module customization, and several CLI improvements. This roundup also covers custom event timeline configuration and new Remote MCP server capabilities for content analytics and landing page creation.

Join the discussion in the Developer Community.

• Current Customer system property now available
• Deduplication of repeated subscription status updates from automations
• Knowledge Vaults now support structured data files
• Automatic activity associations are now available for app objects
• Custom-coded modules are now available for HubSpot quotes
• HubSpot CLI authentication is now centralized
• App logs are now available in the HubSpot CLI
• Custom event timeline cards can now be customized
• Content analytics and landing page creation now available in the Remote MCP server

Current Customer system property now available

HubSpot now provides a system-managed Current Customer property (hs_current_customer) on companies, contacts, and custom objects that flags whether a record is a current customer. It powers default filters in the Customer Success workspace, and you can read it and filter or search on it through the CRM API like any other property — though it's system-managed and read-only to integrations (HubSpot computes and sets the value). New accounts default to lifecycle stage = customer; you can keep that or redefine "current" using a single property, a set of lifecycle stages, or the advanced filter builder. Existing accounts can adopt it without changing their current views. Values are yes, no, or empty (unevaluable/cleared).

Deduplication of repeated subscription status updates from automations

HubSpot is now updating how repeated subscription status updates from automated sources, including workflows, integrations, and API calls, are recorded. Instead of recording subscription statuses for a contact repeatedly When an automated source sends the same subscription status multiple times within a 24-hour period with no meaningful change, HubSpot may consolidate those entries instead of recording each one separately. This makes subscription history cleaner and easier to audit.

Meaningful changes will still be recorded. These include:

• The opt state changes (e.g. subscribed -> unsubscribed)
• The legal basis to communicate is different
• The source type differs (e.g. a contact taking action directly vs. an automated workflow)

Only automated sources will be affected by this deduplication effort.

Knowledge Vaults now support structured data files

Knowledge Vaults now support uploading and querying structured data files — xlsx, csv, json, and xml — so agents can answer analytical and aggregation questions directly from your tabular data.

• Upload the supported file types via the Knowledge Vault file picker; the analysis tool is enabled by default.
• For natural-language lookups, keep using the standard Knowledge Vault tool.

Automatic activity associations are now available for app objects

You can now configure automatic activity associations with app objects. This ensures that activities logged to an app object are available in the records’ timeline, removing the manual step of navigating between associated records and relevant timeline activities, such as logged emails and calls.

Account admins must opt-in to this feature by configuring it in account settings. This means admins can choose which activity types are automatically associated with app objects.

Please note: You can only configure this logging behavior for app objects where an association exists according to the data model configured by the connect app. If the app object is not associated with an activity or a record, the setting will be disabled.

Custom-coded modules are now available for HubSpot quotes

Developers, admins, and solutions partners can now build custom CMS React modules that can be embedded directly into quote templates or individual quotes. These modules make it possible to customize or replace quote sections, such as line item tables, terms and conditions, payment schedules, or fully custom quote layouts, while pulling data from HubSpot CRM or external systems. Teams can use this to create more interactive, data-rich, and brand-controlled quoting experiences for CPQ workflows. Learn more in the high-level overview or explore the custom CMS React modules documentation and sample GitHub project.

HubSpot CLI authentication is now centralized

HubSpot CLI now uses a global authentication model, so developers can authenticate accounts once and link them to specific project directories as needed. Credentials are stored globally in ~/.hscli/config.yml, while each project’s linked accounts are tracked in .hs/settings.json, making account context clearer and reducing the risk of deploying to the wrong account. Developers can use hs account link, hs account default, hs account unlink, and hs account current to manage project-specific account associations. Legacy .hsaccount files are migrated automatically where possible. Learn more in the HubSpot CLI documentation.

App logs are now available in the HubSpot CLI

Developers can now retrieve app logs directly from the terminal using the new hs app logs CLI command. The command supports logs for serverless functions, CRM cards, webhooks, and API calls, with options to filter by app ID, log type, time range, and result limit. Developers can also use --json for structured output or --tail to continuously poll for new logs, making it easier to debug deployed apps and support agent-driven development workflows without switching to the UI. Learn more in the HubSpot CLI documentation.

Custom event timeline cards can now be customized

Users can now control how custom events appear on linked object record timelines, including the card header, subheader, visible properties, and property order. During custom event setup or editing, the new Customize timeline step lets teams use tokens to display real event values, choose which properties appear on the activity card, and preview the result in real time. This makes custom event activity easier to scan and understand without digging into raw event data. Learn more in the custom events documentation.

Content analytics and landing page creation now available in the Remote MCP server

Two new capabilities are live in HubSpot's remote MCP server: content analytics for standalone web assets and landing page creation. Previously, content analytics via MCP was limited to campaign-linked pages. That restriction is removed. You can now query performance data for any landing page, website page, or blog post, including views, form submissions, new contacts, bounce rate, CTA performance, and traffic sources.

Landing page creation is also available. Starting from an existing template or a clone of a page you already have, AI assistants can create, edit, and publish landing pages — including modifying copy, headlines, and CTAs; adding or reordering sections; making style changes; managing form embeds; and publishing (with an explicit confirmation step before the page goes live). Pages appear in your HubSpot account and are fully editable in the page editor. This release doesn't include bulk operations, custom module creation, A/B test setup, or first-time site/account setup.

For end-users using an agent or connector that uses the remote MCP server, if you've already connected HubSpot to an AI assistant, reconnect or re-authorize to grant the new permission scope. New connections prompt for it automatically. For setup details and a full list of available tools, see the HubSpot remote MCP server documentation.

Original source

The HubSpot Agent CLI is a new command-line interface purpose-built for AI agents to interact with your HubSpot CRM data — reading records, running searches, creating and updating objects, managing pipelines, properties, associations, workflows, and more. It's designed for agentic environments like Claude Cowork, Claude Code, and OpenAI Codex, and is particularly well-suited for scheduled automations, bulk operations, and background tasks that need to run without a human in the loop. The Agent CLI is now in public beta.

What's new?

The Agent CLI is a new binary, separate from the HubSpot CLI used for development. A few things worth understanding before you get started:

• It's built for agents. The Agent CLI is designed for AI agents to consume and use — not for developers to operate interactively. That said, you can run it yourself to test it or use it for custom scripting.
• It's separate from the HubSpot developer CLI. The developer CLI is for building and deploying HubSpot projects and themes. The Agent CLI has a separate command surface built for agent consumption. There's some functional overlap, but they serve different purposes and can be used together — for example, an agent could use the Agent CLI to populate mock data in a sandbox account or update production records as part of a developer-driven workflow.
• It doesn't replace the HubSpot MCP server (remote) or AI Connectors. The remote MCP server and AI Connectors remain the right choice for conversational, human-in-the-loop workflows — answering questions, pulling insights, and taking actions in real time from Claude, ChatGPT, and other chat environments. The Agent CLI complements them for the opposite scenario: repetitive, bulk, and scheduled work that runs in the background.
• For agent workflows specifically, a CLI offers practical advantages over MCP for certain use cases: CLI calls can be significantly more token-efficient (no full tool schema needs to be loaded into the agent's context window), there's no protocol negotiation overhead on each call, and commands can follow known terminal patterns — agents can filter, transform, and chain operations in a single step.

What the Agent CLI can do

Commands follow the pattern hubspot . Because the CLI is meant for agents to use, you don't need to really care about the commands themselves, but it helps to understand the capabilities. The current command surface covers:

• CRM objects: list, get, search, create, update, upsert, merge, and delete any object type (contacts, companies, deals, tickets, and custom objects), plus types to enumerate all available object types in the portal
• Pipelines: list, get, create, update, and delete pipelines and pipeline stages
• Properties: list, get, create, update, delete, and batch-manage properties across object types
• Associations: create, delete, and batch-manage associations between records, plus association label and limit management
• Owners: list HubSpot users (record owners)
• Custom object schemas: list, get, create, update, and delete schemas (requires admin mode — see below)
• Workflows: list, get, create, update, and delete workflows
• Activities: list activity history for a CRM record; fetch and delete call and meeting transcripts; list call dispositions; and fetch full email threads
• Reports: (Note: item left blank in original text)
• History: local audit log of all destructive operations run by the CLI

Output defaults to JSONL — a streaming, pipeable format where each line is a valid JSON object. Use --format json for a wrapped array with metadata, or --format table for a human-readable ASCII table.

Every write command supports a --dry-run flag that previews changes without applying them. Use it before running any mutation, especially against production accounts.

Authentication

The CLI supports two authentication modes:

• OAuth login: scoped to your HubSpot user-level permissions. Recommended for most agent workflows.
• Admin mode via service key: set a service key as HUBSPOT_ACCESS_TOKEN. Required for schema operations, most delete operations, reliable pipeline stage, and owner metadata resolution, and certain association types. Use with caution — this token carries broader permissions and doesn't generate a per-user audit trail.

Access control for admins

Super admins can use App Governance (beta) to control which users can connect the Agent CLI to a HubSpot account via OAuth. This doesn't restrict who can download the binary, but it does gate account-level data access. Learn more about managing access to apps.

If your organization uses Claude Team or Enterprise, your admin will also need to allowlist api.hubapi.com in Claude's network egress settings before the CLI can install or run from a Cowork session. Setup steps are covered in the Agent CLI guide.

For the full command reference, authentication details, piping examples, and output format documentation, see the Agent CLI guide.

When is it happening?

The HubSpot Agent CLI is now in public beta. To give it a try open your favorite agentic coding tool like Claude or Codex and paste the following prompt:

Install the HubSpot Agent CLI in this agent workspace. If this workspace uses a POSIX shell (macOS, Linux, WSL, or Bash), run curl -fsSL https://api.hubapi.com/hub/cli/backend/hub-cli/latest/install.sh | sh. If it uses Windows PowerShell, run irm https://api.hubapi.com/hub/cli/backend/hub-cli/latest/install.ps1 | iex. Then authenticate with hubspot auth login, install HubSpot Agent CLI Skills with npx skills add hubspot/agent-cli-skills, and use hubspot --help to explore what's available.

Questions or comments? Join us in the developer forums.

Original source

We’ve improved our SDK releases to support date-based API versioning, the new /YYYY-MM/ format introduced across HubSpot’s APIs. Generated from a centrally managed API specification, SDKs now cover more endpoints across multiple languages and release faster, so your clients stay aligned with the APIs you're building on.

The SDKs currently support the following languages:

• PHP
• Java
• Ruby
• Go
• TypeScript
• Python

Why does it matter?

Until now, gaps in SDK endpoint coverage meant you had to work around missing methods or rely on raw HTTP calls where a typed client would have been cleaner. With SDKs generated from a single, centrally managed spec, coverage expands significantly. Because the spec stays in sync with HubSpot's APIs as they evolve, you're less likely to encounter documentation drift or unexpected breaking changes. Updated packages are also distributed through standard package managers, so adopting new versions fits into your existing workflow.

How does it work?

The updated SDK packages are available through standard package managers, such as npm, so there are no changes that need to be made to your authentication setup or initialization.

To learn more about the updated SDKs, please check out the repositories.

Original source

We’ve improved our SDK releases to support date-based API versioning, the new /YYYY-MM/ format introduced across HubSpot’s APIs. Generated from a centrally managed API specification, SDKs now cover more endpoints across multiple languages and release faster, so your clients stay aligned with the APIs you're building on.

The SDKs currently support the following languages:

• PHP
• Java
• Ruby
• Go
• TypeScript
• Python

Why does it matter?

Until now, gaps in SDK endpoint coverage meant you had to work around missing methods or rely on raw HTTP calls where a typed client would have been cleaner. With SDKs generated from a single, centrally managed spec, coverage expands significantly. Because the spec stays in sync with HubSpot's APIs as they evolve, you're less likely to encounter documentation drift or unexpected breaking changes. Updated packages are also distributed through standard package managers, so adopting new versions fits into your existing workflow.

How does it work?

The updated SDK packages are available through standard package managers, such as npm, so there are no changes that need to be made to your authentication setup or initialization.

To learn more about the updated SDKs, please check out the repositories.

Original source

This month brings a set of updates aimed at making everyday building better. Breeze Assistant steps further into your workflows, a new useCrmSearch hook shipped for UI extensions, stage calculated properties available for custom objects and the HubSpot CLI got a fresh round of improvements — plus updates to blog author attribution, IP range webhooks, and more. Read on below for the details.

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

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