Nathan Drezner

November 12, 2025

What's New in Dash 3.3.0: Plotly Cloud, customizable developer tools, and more

Plotly has released Dash 3.3.0, bringing a powerful set of features that bridge the gap between development and production deployment. We’re focusing on three key areas: integration with Plotly Cloud, enhanced developer tools customization, and production monitoring capabilities. We’re also introducing improvements for callbacks, and a host of bug fixes and minor improvements.

Plotly Cloud integration in developer tools

Get started with a free Plotly Cloud account.

Plotly Cloud is the easiest way to publish data applications to the cloud in seconds. The developer tools panel now features native Plotly Cloud integration when you install the cloud extension (pip install "dash[cloud]"). You can sign in, publish apps, and check deployment status directly from your development environment with no context switching required.

Customizable developer tools UI

Learn more here.

One of the standout features in Dash 3.3.0 is the new hooks.devtool API, which allows you to extend the developer tools panel with custom components. Whether you're building internal tools, debugging utilities, or custom monitoring interfaces, you can now integrate them into your development workflow.

For example, it’s possible to build sophisticated callback profiling tools, production status monitors, display app dependencies, and more. Configuring these types of controls as plugins means they won’t be shown in production more easily, but remain right at hand in the developer tools UI while locally.

You can also share these plugins with the world: Like other hooks, we encourage bundling and distributing developer tools extensions you build as Python packages on PyPI. You can learn more about that process here.

Adding custom components

The hooks.devtool API makes it straightforward to add both Dash components and custom React components to the developer tools UI:

from dash import hooks

hooks.devtool(
    namespace="dash_html_components",
    component_type="Div",
    props={"children": "Custom plugin developer tools panel"},
    position="right"  # "left" for toggles, "right" for indicators
)

Interactive developer tools with callbacks

You can make your custom developer tools interactive by combining hooks.devtool with hooks.callback. The new optional=True parameter ensures callbacks work even when components are outside the regular layout:

@hooks.callback(
    Output("plugin-output", "children"),
    Input("plugin-button", "n_clicks"),
    optional=True,
    prevent_initial_call=True
)
def handle_plugin_button(n_clicks):
    returnf"Button clicked {n_clicks} times"

Consistent styling

For developers creating custom React components, Dash 3.3.0 introduces a devtool component API that ensures your plugins match the built-in developer tools styling:

const { popup, setPopup } = window.dash_component_api.devtool.useDevtool();
constclassName=window.dash_component_api.devtool.useDevtoolMenuButtonClassName('my-popup-id');

Callbacks as HTTP API endpoints

Learn more here.

Big thank you to community member Bryan Schroeder (@BSd3v) for contributing this feature.

Dash 3.3.0 introduces the ability to expose any callback as an HTTP API endpoint using the api_endpoint parameter. This opens up powerful integration possibilities, allowing external systems to trigger Dash callbacks.

@callback(
    Output('square', 'children'),
    Output('cube', 'children'),
    Input('num-multi', 'value'),
    api_endpoint='/api/calculate'
)
def calculate_powers(x):
    if x is None:
        return '', ''
    results = (x**2, x**3)
    
    # Return normally for browser, JSON for API
    if ctx:
        return results
    return jsonify(results)

app.setup_apis()  # Required before app.run()

External systems can now call your callback logic via HTTP POST:

import requests
response = requests.post('http://localhost:8050/api/calculate',
                        json={'x': 3})
print(response.json())  # [9, 27]

This feature is perfect for:

Microservice architectures
Automated testing and CI/CD pipelines
Integration with non-Python systems
Batch processing workflows

Health endpoints for production monitoring

Learn more here.

Big thank you to first-time contributor Luiz Felipe (@lfelipediniz) for contributing this feature.

Production deployments just got easier with the new health endpoint feature. Configure a simple health check endpoint that integrates with load balancers, Docker health checks, Kubernetes probes, and uptime monitoring:

from dash import Dash

app = Dash(health_endpoint="health")
# Available at /health, returns "OK" with HTTP 200

This is especially useful for:

Load balancer health checks
Container orchestration (Docker, Kubernetes)
Uptime monitoring services
CI/CD pipeline validation

Clientside partial property updates

Learn more here.

Big thank you to community member Bryan Schroeder (@BSd3v) for contributing this feature.
For performance-critical applications, Dash 3.3.0 introduces dash_clientside.Patch for making surgical updates to component properties without full re-renders. This is particularly powerful for updating complex objects like Plotly figures:

function(n_clicks) {
    const patch = new dash_clientside.Patch();
    const showLegend = n_clicks % 2 === 0;
    
    return patch
        .assign(['layout', 'showlegend'], showLegend)
        .build();
}

The Patch API supports a comprehensive set of operations:

.assign() - Update property values
.append(), .prepend(), .extend() - Array manipulation
.merge() - Object merging
.delete(), .clear() - Property removal
.add(), .sub(), .mul(), .div() - Numeric operations

Enhanced callback configuration

Dash 3.3.0 introduces two powerful new callback parameters that give you more control over how callbacks behave:

Optional callback inputs

Learn more here.

The new optional=True parameter can now be set at the callback level, making all inputs, states, and outputs optional. This simplifies working with dynamically generated components or developer tools:

@app.callback(
    Output("optional-output", "children"),
    Input("button-1", "n_clicks"),
    Input("button-2", "n_clicks"),
    optional=True,
    prevent_initial_call=True
)
def handle_clicks(n_clicks1, n_clicks2):
    returnf"Button 1: {n_clicks1} - Button 2: {n_clicks2}"

Hidden callbacks for cleaner developer tools

Learn more here.

When building plugins or internal utilities, you can now use hidden=True to hide callbacks from the callback graph in developer tools.

This keeps the developer tools UI focused on the user's application logic rather than cluttered with internal plugin callbacks:

from dash import hooks, Input, Output

@hooks.callback(
    Output("message-container", "children"),
    Input("app-button", "n_clicks"),
    prevent_initial_call=True,
    hidden=True
)
def output_message(n_clicks):
    if n_clicks:
        return"Displaying a message in the app on click"

If you’re a plugin developer, you may find this feature particularly helpful, as you can add complex interactivity to your plugins without cluttering the developer tools UI for developers leveraging your plugin.

Support for Python 3.14

Dash now fully supports Python 3.14. For developers who are looking to upgrade their Python to π-thon, ensure you first update Dash to >= 3.3.0.

If you really want to take the training wheels off of Dash 3.3.0, try out free-threaded Python 3.14. This hasn’t been deeply tested on our side, but we’re excited about the coming changes and curious to hear from the community if full support is something you are interested in. You can contribute to the discussion here.

Deprecation of Dash Table

We’re deprecating Dash Table from the core Dash API, and it will be removed from the core API of Dash starting with Dash 5.0. We expect Dash 5.0 sometime in 2026 following Dash 4.0, so while there's a good window before removal, you may consider changing your imports or moving off of Dash Table. If you’re using Dash Table today, we’d encourage migrating to Dash Ag Grid which has more functionality and is better supported.

You can get started with pip install “dash[ag-grid]”, a new shortcut for installation available in Dash 3.3.0. You can also consult the Dash Ag Grid documentation.

Other changes and new contributors

As always, you’ll see improvements and bug fixes across the board. A few notable changes contributed by our community to call out:

@enioarz , a first time contributor, who contributed support for reverse direction slider
@CNFeffery, who fixed the error triggered when only a single no_update is returned for client-side callback functions with multiple Outputs
@R3myG, who fixed the DeprecationWarning in dash/_jupyter.py by migrating from deprecated ipykernel.comm.Comm to comm module

Thank you, and if you’re looking to get started contributing to Dash for the first time, we’re always happy to help. Open a ticket or PR and tag Philippe Duval (@T4rk1n), Emily Kellison-Linn (@emilykl), Nathan Drezner (@ndrezn), or any other members of the Plotly team for support.

Getting started

Upgrade to Dash 3.3.0 to access these features:

pip install --upgrade dash

To get started publishing your apps to Plotly Cloud directly from Dash, add the Plotly Cloud extension:

pip install "dash[cloud]"

What’s next?

Dash 3.3.0 represents a significant step forward in making Dash applications more flexible, maintainable, and production-ready. The customizable developer tools empower teams to build better development workflows, while API endpoints and health checks make enterprise deployment scenarios first-class citizens.

Whether you're building internal dashboards, data science applications, or production analytics platforms, these new features provide the tools you need to work more efficiently and deploy with confidence.

The documentation for these features is live today. Take a look at the full documentation to explore these features in depth and see how they can enhance your Dash applications.

If you’re curious about what we’re building next, take a look at our public roadmap and feel free to provide feedback, commentary, or ideas. And of course, keep building!