Show Sidebar Hide Sidebar

Static Image Export in Python

Plotly allows you to save static images of your plots. Save the image to your local computer, or embed it inside your Jupyter notebooks as a static image.

New to Plotly?¶

Plotly's Python library is free and open source! Get started by downloading the client and reading the primer.
You can set up Plotly to work in online or offline mode, or in jupyter notebooks.
We also have a quick-reference cheatsheet (new!) to help you get started!

Version Check¶

Note: The static image export API is available in version 3.2.0.+

In [1]:
import plotly

plotly.__version__
Out[1]:
'3.2.0'

Static Image Export¶

New in version 3.2.0. It's now possible to programmatically export figures as high quality static images while fully offline.

Install Dependencies¶

Static image generation requires the orca commandline utility and the psutil Python library. There are 3 general approach to installing these dependencies.

conda¶

Using the conda package manager, you can install these dependencies in a single command:

$ conda install -c plotly plotly-orca psutil

Note: Even if you don't want to use conda to manage your Python dependencies, it is still useful as a cross platform tool for managing native libraries and command-line utilities (e.g. git, wget, graphviz, boost, gcc, nodejs, cairo, etc.). For this use-case, start with Miniconda (~60MB) and tell the installer to add itself to your system PATH. Then run conda install plotly-orca and the orca executable will be available system wide.

npm + pip¶

You can use the npm package manager to install orca (and its electron dependency), and then use pip to install psutil:

$ npm install -g electron@1.8.4 orca
$ pip install psutil
Standalone Binaries + pip¶

If you are unable to install conda or npm, you can install orca as a precompiled binary for your operating system. Follow the instructions in the orca README to install orca and add it to your system PATH. Then use pip to install psutil.

$ pip install psutil

Create a Figure¶

Now let's create a simple scatter plot with 100 random points of variying color and size.

In [2]:
from plotly.offline import iplot, init_notebook_mode
import plotly.graph_objs as go
import plotly.io as pio

import os
import numpy as np

We'll configure the notebook for use in offline mode

In [3]:
init_notebook_mode(connected=True)
In [4]:
N = 100
x = np.random.rand(N)
y = np.random.rand(N)
colors = np.random.rand(N)
sz = np.random.rand(N)*30

fig = go.Figure()
fig.add_scatter(x=x,
                y=y,
                mode='markers',
                marker={'size': sz,
                        'color': colors,
                        'opacity': 0.6,
                        'colorscale': 'Viridis'
                       });
iplot(fig)

Write Image File¶

The plotly.io.write_image function is used to write an image to a file or file-like python object.

Let's first create an output directory to store our images

In [5]:
if not os.path.exists('images'):
    os.mkdir('images')

If you are running this notebook live, click to open the output directory so you can examine the images as they're written.

Raster Formats: PNG, JPEG, and WebP¶

Orca can output figures to several raster image formats including PNG, ...

In [6]:
pio.write_image(fig, 'images/fig1.png')

JPEG, ...

In [7]:
pio.write_image(fig, 'images/fig1.jpeg')

and WebP

In [8]:
pio.write_image(fig, 'images/fig1.webp')

Vector Formats: SVG and PDF...¶

Orca can also output figures in several vector formats including SVG, ...

In [9]:
pio.write_image(fig, 'images/fig1.svg')

PDF, ...

In [10]:
pio.write_image(fig, 'images/fig1.pdf')

and EPS (requires the poppler library)

In [11]:
pio.write_image(fig, 'images/fig1.eps')

Note: It is important to note that any figures containing WebGL traces (i.e. of type scattergl, heatmapgl, contourgl, scatter3d, surface, mesh3d, scatterpolargl, cone, streamtube, splom, or parcoords) that are exported in a vector format will include encapsulated rasters, instead of vectors, for some parts of the image.

Get Image as Bytes¶

The plotly.io.to_image function is used to return an image as a bytes object.

Let convert the figure to a PNG bytes object...

In [12]:
img_bytes = pio.to_image(fig, format='png')

and then display the first 20 bytes.

In [13]:
img_bytes[:20]
Out[13]:
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x02\xbc'

Display Bytes as Image Using IPython.display.Image¶

A bytes object representing a PNG image can be displayed directly in the notebook using the IPython.display.Image class. This also works in the Qt Console for Jupyter!

In [14]:
from IPython.display import Image
Image(img_bytes)
Out[14]:

Change Image Dimensions and Scale¶

In addition to the image format, the to_image and write_image functions provide arguments to specify the image width and height in logical pixels. They also provide a scale parameter that can be used to increase (scale > 1) or decrease (scale < 1) the physical resolution of the resulting image.

In [15]:
img_bytes = pio.to_image(fig, format='png', width=600, height=350, scale=2)
Image(img_bytes)
Out[15]:

Summary¶

In summary, to export high-quality static images from plotly.py all you need to do is install orca and psutil and then use the plotly.io.write_image and plotly.io.to_image functions.

If you want to know more about how the orca integration works, or if you need to troubleshoot an issue, please check out the Orca Management section.

Still need help?
Contact Us

For guaranteed 24 hour response turnarounds, upgrade to a Developer Support Plan.