Streamlit Plotly Chart Deprecation Warning: How To Fix It

Jan 17, 2026 by Editorial Team 58 views

Zkpvagmrx Gzflqv plotly_chart kwargs Deprecation Warning Jouag Bhmrxdio

Understanding the Streamlit Plotly Deprecation Warning

Encountering deprecation warnings can be a real headache, especially when you're trying to keep your Streamlit apps running smoothly. In this article, we'll dive into a specific issue: the plotly_chart kwargs deprecation warning that pops up when using st.plotly_chart in Streamlit. This warning can appear even when you're not explicitly passing any variable keyword arguments and are only using the documented parameters.

So, what's causing this? Well, it seems like there's a bit of a snag in the way Streamlit handles the width (or height) parameter. Even if you're just setting the width to "content", the system might still trigger the deprecation warning. This is definitely not ideal, as it can be confusing and make you think you're doing something wrong when you're actually following the documentation. Keep reading, guys, we'll explore how to tackle this annoying issue.

Why This Matters

For those new to Streamlit, st.plotly_chart is a fantastic way to embed interactive Plotly charts directly into your web applications. Setting the width to "content" is particularly useful because it allows the chart to responsively fill the available space, making your dashboards look slick on any screen size. When a deprecation warning appears unexpectedly, it not only clutters your console but also raises concerns about the future compatibility of your code. Nobody wants their app to break with the next update!

Furthermore, this issue highlights the importance of clear and accurate documentation. When developers rely on official documentation, they expect the code to behave as described. A deprecation warning that contradicts the documentation can lead to wasted time and frustration as developers try to debug what they believe is an error in their code. So, let's get this sorted out.

Reproducible Code Example

To illustrate the problem, here’s a simple code snippet that triggers the warning:

import plotly.graph_objects as go
import streamlit as st

fig = go.Figure()
fig.add_trace(go.Barpolar(r=[1], theta=[0], width=[120]))
fig.update_layout(width=500, height=360)

st.plotly_chart(fig, width="content")

When you run this code, you'll likely see the deprecation warning, even though you're only using the width parameter as intended.

Breaking Down the Code

Let's quickly break down what this code does:

Import Libraries: We start by importing plotly.graph_objects as go and streamlit as st.
Create a Figure: We create a basic Plotly figure using go.Figure().
Add a Trace: We add a Barpolar trace to the figure. This creates a polar bar chart with a single bar.
Update Layout: We set the width and height of the chart using fig.update_layout().
Display Chart: Finally, we display the chart in Streamlit using st.plotly_chart(fig, width="content"). The width="content" argument is supposed to make the chart responsive.

Despite this straightforward setup, the deprecation warning stubbornly appears.

Steps To Reproduce

To reproduce this issue, simply run the code example provided above in a Streamlit environment. Ensure that you are using Streamlit version 1.50.0 or a similar version where this issue is present.

Install Streamlit and Plotly: If you haven't already, install Streamlit and Plotly using pip:
```
pip install streamlit plotly
```
Save the Code: Save the code example as a Python file (e.g., app.py).
Run the App: Run the Streamlit app from your terminal:
```
streamlit run app.py
```
Observe the Warning: Open the app in your browser and check your terminal. You should see the deprecation warning.

Diving Deeper: Why Is This Happening?

The root cause of this issue lies in the internal handling of keyword arguments within the st.plotly_chart function. The function seems to be overly aggressive in detecting keyword arguments, even when only documented parameters like width are used. The relevant code snippet causing the warning is:

if kwargs:
    show_deprecation_warning(
        "Variable keyword arguments for st.plotly_chart have been "
        "deprecated and will be removed in a future release. Use the "
        "config argument instead to specify Plotly configuration "
        "options."
    )

This code checks if there are any keyword arguments (kwargs) passed to st.plotly_chart. If there are, it triggers the deprecation warning. The problem is that the width parameter, although a documented and valid argument, is still being caught by this check.

Is This a Regression?

Yes, this appears to be a regression. Users have reported that this code used to work without triggering the deprecation warning in previous versions of Streamlit. This means that a recent change in the codebase has inadvertently introduced this issue.

Expected Behavior

When using the width argument as documented, users should not receive a deprecation warning. The width argument should be recognized as a valid parameter, and the chart should render without any unnecessary warnings.

What We Want

Ideally, the st.plotly_chart function should be updated to correctly identify and handle the documented parameters like width and height without triggering the deprecation warning. This would provide a smoother and more intuitive experience for developers using Streamlit with Plotly charts.

Current Behavior

Currently, the deprecation warning is triggered even when using the width parameter as intended:

Variable keyword arguments for st.plotly_chart have been deprecated and will be removed in a future release. Use the config argument instead to specify Plotly configuration options.

This warning is misleading and can cause confusion, as it suggests that the width parameter is deprecated, which is not the case.

Debug Info

Here’s the debug information for the environment where this issue was observed:

Streamlit version: 1.50.0
Python version: Python 3.14.2
Operating System: MacOs 26.1
Browser: Chrome

This information can be helpful for developers and maintainers to reproduce and address the issue.

Possible Solutions and Workarounds

While we wait for an official fix, here are a few potential workarounds to mitigate the deprecation warning:

Ignore the Warning (Not Recommended): You could choose to ignore the warning, but this is generally not a good practice. Deprecation warnings are there for a reason, and ignoring them could lead to compatibility issues in the future.
Use config Argument (If Applicable): If you need to specify Plotly configuration options, use the config argument as suggested in the warning message. However, this workaround does not directly address the width parameter issue.
Downgrade Streamlit Version (Temporary): If this issue is critical for your application, you could temporarily downgrade to a previous version of Streamlit where this issue was not present. However, this may mean missing out on new features and bug fixes in the latest version.

Contributing to a Solution

If you're feeling adventurous, you could contribute to the Streamlit project by submitting a pull request with a fix for this issue. Here’s a general approach:

Fork the Streamlit Repository: Fork the Streamlit repository on GitHub.
Identify the Problem Code: Locate the relevant code in the st.plotly_chart function that triggers the deprecation warning.
Implement a Fix: Modify the code to correctly identify and handle the documented parameters like width without triggering the warning.
Test Your Fix: Test your fix thoroughly to ensure that it resolves the issue without introducing any new problems.
Submit a Pull Request: Submit a pull request with your fix to the Streamlit repository.

Conclusion

The plotly_chart kwargs deprecation warning in Streamlit is a minor but annoying issue that can cause confusion for developers. By understanding the root cause of the problem and exploring potential solutions and workarounds, we can mitigate the impact of this issue and continue to build awesome Streamlit apps with Plotly charts. Remember to keep an eye on Streamlit updates and contribute to the project if you have the skills and time to do so. Together, we can make Streamlit even better!

And don't worry, Streamlit is continuously improving, so hopefully, this gets fixed soon! Happy coding, folks!

Additional Information

No response