{"id":23406,"date":"2023-04-09T13:17:16","date_gmt":"2023-04-09T13:17:16","guid":{"rendered":"https:\/\/www.highcharts.com\/blog\/?p=23406"},"modified":"2026-01-13T11:29:37","modified_gmt":"2026-01-13T11:29:37","slug":"highcharts-maps-python-basic-tutorial","status":"publish","type":"post","link":"https:\/\/www.highcharts.com\/blog\/integration\/highcharts-maps-python-basic-tutorial\/","title":{"rendered":"Using Highcharts Maps for Python &#8211; Basic Tutorial"},"content":{"rendered":"<p><b><a href=\"https:\/\/www.highcharts.com\/products\/maps\/\" target=\"_blank\" rel=\"noopener\">Highcharts Maps<\/a><\/b> is a powerful JavaScript data visualization library that enables you to design rich, beautiful, and highly interactive data visualizations of geographic information. And using Highcharts Maps for Python, which is part of the broader <a href=\"https:\/\/github.com\/highcharts-for-python\" target=\"_blank\" rel=\"noopener\">Highcharts for Python Toolkit<\/a>, you can easily and rapidly use Highcharts Maps in your Python code.<br \/>\nIn addition to providing you with over 70 different base visualizations, Highcharts Maps and Highcharts Maps for Python also give you the capability to construct rich map visualizations including:<\/p>\n<ul>\n<li>Zoomable visualizations letting you zoom in and out of your map.<\/li>\n<li>The inclusion of dynamic map insets showing more detail or different data to deliver richer insights.<\/li>\n<li>Five different map projections to choose from included out of the box, as well as the ability to apply a custom projection algorithm.<\/li>\n<li>Support for map definitions in TopoJSON, GeoJSON, or ESRI Shapefile format.<\/li>\n<\/ul>\n<p><b>Highcharts Maps for Python<\/b> will not render data visualizations itself &#8211; that\u2019s what Highcharts Maps (in JavaScript) does &#8211; but it will allow you to:<\/p>\n<ol>\n<li>Configure your map in Python.<\/li>\n<li>Configure your map data visualizations\/interactivity in Python.<\/li>\n<li>Supply data you have in Python to your data visualizations.<\/li>\n<li>Programmatically produce the Highcharts Maps JavaScript code that will actually render your data visualization.<\/li>\n<li>Programmatically download a static version of your visualization (as needed) within Python.<\/li>\n<\/ol>\n<p><i><br \/>\n<b>Tip<\/b><br \/>\nThink of <b>Highcharts Maps for Python<\/b> as a translator to bridge your data visualization needs between Python and JavaScript.<br \/>\n<\/i><\/p>\n<h2>Getting Started with Highcharts Maps for Python<\/h2>\n<p>To use Highcharts Maps for Python, like with any Python library, you first have to install it. That\u2019s super easy: just open your Python project (in your virtual environment \u2013 you are using virtual environments, right?) and execute:<\/p>\n<pre>$ pip install highcharts-maps<\/pre>\n<p>And that\u2019s it! Highcharts Maps for Python will now be installed in your project and available for use. To use it in your code, you just have to import it the way you would any other library.<\/p>\n<h2>What\u2019s Included in Highcharts Maps for Python?<\/h2>\n<p>Highcharts Maps for Python is specifically designed to provide rich time series visualization in your Python code. While the base Highcharts for Python library is designed to provide rich interactive visualizations, Highcharts Maps for Python goes further to provide you with:<\/p>\n<ul>\n<li><b>Limitless Mapping \u2013 but Batteries Included<\/b>. While Highcharts Maps for Python lets you easily build custom maps from your own GeoJSON, TopoJSON, or ESRI Shapefile data, you can also leverage one of Highsoft\u2019s existing 500+ maps right out of the box.<\/li>\n<li><b>Rich Data Visualization<\/b>. Highcharts Maps supports multiple different types of map visualizations, including choropleth (heat map) visualizations, map area visualizations, map line visualizations, map bubble plots, and tilemap representations.<\/li>\n<li><b>Robust Navigation within and across Your Map<\/b>. Highcharts Maps for Python provides you with the ability to let your users easily navigate to different time periods in your data, using any combination of:\n<ul>\n<li>Mouse and touch-enabled scrolling and panning.<\/li>\n<li>Mouse and touch-enabled zooming.<\/li>\n<li>Plus or minus buttons that zoom you in or out, respectively.<\/li>\n<\/ul>\n<\/li>\n<li><b>Custom Projections \u2013 but Batteries Included<\/b>. Highcharts Maps supports five different commonly-used projections out of the box, but it also gives you the ability to write your own custom project projection algorithm easily and quickly.<\/li>\n<li><b>Highcharts for Python<\/b>. Highcharts Maps for Python includes the complete Highcharts for Python library, with the exact same API. This lets you import one library for all of your data visualization needs, whether working with map data or any other kind of data.<\/li>\n<\/ul>\n<h2>Importing Highcharts Maps for Python<\/h2>\n<p>The Highcharts Maps for Python library is quite big. It\u2019s got a rich (read: complicated) API, with lots of different objects and modules. That\u2019s a reflection of the visualization power that Highcharts offers you, but it does make the decision of what to import and how to import it a little more complicated.<br \/>\nPython best practice is to import only what you need, which helps to maximize the performance of your Python code and prevents your application\u2019s namespace from getting cluttered with various things (and further reducing the memory footprint of your Python code, which is always good).<\/p>\n<p>You can either import specific things from their precise locations, or you can also just import the catch-all <code>highcharts<\/code> module, which flattens the entire API and exposes just about every class\/object in one location. We definitely recommend importing things from their precise location like so:<\/p>\n<pre># Import classes using precise module indications. For example:\r\nfrom highcharts_maps.chart import Chart\r\nfrom highcharts_maps.global_options.shared_options import SharedMapsOptions\r\nfrom highcharts_maps.options import HighchartsMapsOptions\r\nfrom highcharts_maps.options.plot_options.mapbubble import MapBubbleOptions\r\nfrom highcharts_maps.options.series.mapbubble import MapBubbleSeries<\/pre>\n<p>As you can see, the import pattern for Highcharts Maps for Python is very similar to Highcharts for Python. That is because Highcharts Maps for Python is an extension of the Highcharts for Python library, and it maintains the full API. Highcharts Maps features are additive in relation to that API, so you can import from one toolkit library throughout your application.<br \/>\nFor example, if you wish to render a Map Bubble chart using Highcharts Maps for Python, but also render a separate Sankey chart (available in Highcharts for Python), you can do both while using the Highcharts Maps for Python library:<\/p>\n<pre>from highcharts_maps.chart import Chart\r\nfrom highcharts_maps.global_options.shared_options import SharedMapsOptions\r\nfrom highcharts_maps.options import HighchartsMapsOptions\r\nfrom highcharts_maps.options.plot_options.mapbubble import MapBubbleOptions\r\nfrom highcharts_maps.options.series.mapbubble import MapBubbleSeries\r\nfrom highcharts_maps.options.plot_options.sankey import SankeyOptions\r\nfrom highcharts_maps.options.series.sankey import SankeySeries<\/pre>\n<h2>A Super Simple Example<\/h2>\n<p>While your project is likely more complicated, let\u2019s take a look at the easiest use case: visualizing some data quickly and easily. You likely have your data in a CSV file, or perhaps in a Pandas <code>dataframe<\/code>, or maybe just stored in a <code>list<\/code> in your Python code. Highcharts Maps for Python can work with all of those scenarios.<\/p>\n<h3>Setup Your Map<\/h3>\n<p>When configuring your map visualization, obviously you need to configure the actual map your visualization will be rendering. All maps are defined by their <code>geometries<\/code>, which is a fancy way of saying they are defined by a very precise definition of the lines and shapes that make up the map.<br \/>\nTypically, your map definition will be stored in either <code>GeoJSON<\/code>, <code>TopoJSON<\/code>, or ESRI <code>Shapefile<\/code> files. Highcharts for Maps natively supports these formats, automatically rendering the maps defined by their content.<br \/>\nThe map used in your visualization can be defined in two separate places, either in your chart\u2019s <code>.options.chart.map<\/code> property, or in a given series\u2019 <code>.map_data<\/code> property. Both of these properties expect a <code>MapData<\/code> or <code>AsyncMapData<\/code> instance, which tells Highcharts Maps where and how to find the geometry to render your map.<\/p>\n<p><i><br \/>\n<b>Tip<\/b><br \/>\n<b>Best practice!<\/b>: It is recommended to use <code>options.chart.map<\/code> to configure your visualization\u2019s map. This is because laying out a single visualization that has multiple series represented on multiple maps is a very complicated configuration, and is rarely necessary.<br \/>\n<\/i><\/p>\n<p>Your map itself is defined using either <code>GeoJSON<\/code>, <code>TopoJSON<\/code>, or <code>Shapefile<\/code> formats. The most important decision you will need to make is whether you wish to load your map data synchronously within <b>Highcharts Maps for Python<\/b> and then supply the chart definition and the map definition to your (JavaScript) client, or whether you would prefer to load the map definition asynchronously within your (JavaScript) client. Highcharts Maps for Python supports both approaches, and makes doing both very simple.<\/p>\n<p><i><br \/>\n<b>Tip<\/b><br \/>\n<b>Best practice!<\/b>: Because map data can be verbose and relatively large on the wire, we prefer to rely on the asynchronous method, but there are plenty of valid use cases where the synchronous approach is the best choice.<br \/>\n<\/i><\/p>\n<h3>Using AsyncMapData<\/h3>\n<p>You can configure your visualization to load your map data asynchronously by supplying an <code>AsyncMapData<\/code> instance to either your <code>Chart<\/code> instance\u2019s <code>.options.chart.map<\/code> or your Series\u2019 <code>.map_data<\/code> as described above. The <code>AsyncMapData<\/code> instance contains a configuration that tells <b>Highcharts for Maps<\/b> how to have your JavaScript client download (using JavaScript\u2019s <code>fetch()<\/code>) your map data.<\/p>\n<p>Let\u2019s assume that we have a <code>Chart<\/code> instance called <code>my_chart<\/code>. We can configure its map data with one method call:<\/p>\n<pre># Set the chart\u2019s map data, configured to load asynchronously\r\nmy_chart.set_map_data('https:\/\/code.highcharts.com\/mapdata\/custom\/world.topo.json')<\/pre>\n<p>That\u2019s all you have to do! When you now serialize your <code>my_chart<\/code> variable to JavaScript using the <code>.to_js_literal()<\/code> method, you will have an asynchronous <code>fetch()<\/code> call which downloads the <code>world.topo.json<\/code> data from the URL you provided.<\/p>\n<p>If your asynchronous map data is a bit more complicated, you can create an <code>AsyncMapData<\/code> instance and simply pass the <code>.set_map_data()<\/code> method that instance. This is typically used if you want to only use a subset of your topology, or if you need to customize the authentication credentials used when downloading your map geometry.<\/p>\n<pre>from highcharts_maps.options.series.data.map_data import AsyncMapData\r\n# An equivalent way of doing this to create an AsyncMapData instance:\r\nmy_map_data = AsyncMapData(\r\n    url = 'https:\/\/code.highcharts.com\/mapdata\/custom\/world.topo.json'\r\n)\r\nmy_chart.set_map_data(my_map_data)<\/pre>\n<p>For more details on how to use AsyncMapData, please review the t<a href=\"https:\/\/www.highcharts.com\/blog\/tutorials\/highcharts-maps-python-asynchronous-map-data\" target=\"_blank\" rel=\"noopener\">utorial Highcharts Maps for Python: Working with Asynchronous Map Data<\/a>.<\/p>\n<h3>Using MapData<\/h3>\n<p>If you do not want to load your map data asynchronously in your JavaScript client, you can supply your map <code>geometries<\/code> directly within Python as well, and that map data will then be serialized to JavaScript along with your chart definition when you call <code>.to_js_literal()<\/code> on your Chart instance.<br \/>\nSynchronous map data is represented as a MapData instance. This object can most easily be created by calling one of its deserializer methods:<\/p>\n<ul>\n<li><code><a href=\"https:\/\/maps-docs.highchartspython.com\/en\/latest\/api\/options\/series\/data\/map_data.html#highcharts_maps.options.series.data.map_data.MapData.from_topojson\" target=\"_blank\" rel=\"noopener\">.from_topojson()<\/a><\/code><\/li>\n<li><code><a href=\"https:\/\/maps-docs.highchartspython.com\/en\/latest\/api\/options\/series\/data\/map_data.html#highcharts_maps.options.series.data.map_data.MapData.from_geojson\" target=\"_blank\" rel=\"noopener\">.from_geojson()<\/a><\/code><\/li>\n<li><code><a href=\"https:\/\/maps-docs.highchartspython.com\/en\/latest\/api\/options\/series\/data\/map_data.html#highcharts_maps.options.series.data.map_data.MapData.from_geodataframe\" target=\"_blank\" rel=\"noopener\">.from_geodataframe()<\/a><\/code><\/li>\n<li><a href=\"https:\/\/maps-docs.highchartspython.com\/en\/latest\/api\/options\/series\/data\/map_data.html#highcharts_maps.options.series.data.map_data.MapData.from_shapefile\" target=\"_blank\" rel=\"noopener\"><code>.from_shapefile()<\/code><\/a><\/li>\n<\/ul>\n<p>Each of these class methods will return a <code>MapData<\/code> instance whose <code>.topology<\/code> property will now be populated with your <code>map geometry<\/code>:<\/p>\n<pre># Load Map Data from a TopoJSON file\r\nmy_map_data = MapData.from_topojson('my-map-data.topo.json')\r\n# Load Map Data from a TopoJSON string \"my_topojson_string\"\r\nmy_map_data = MapData.from_topojson(my_topojson_string)\r\n# Load Map Data from a GeoPandas GeoDataFrame \u201cgdf\u201d\r\nmy_map_data = MapData.from_geodataframe(gdf)\r\n# Apply the MapData to your chart.\r\nmy_chart.set_map_data(my_map_data)<\/pre>\n<p>And that\u2019s it! The logic (and even the syntax) is basically the same, regardless of whether you are loading your map geometries from TopoJSON, GeoJSON, an ESRI Shapefile, or a GeoPandas <code>GeoDataFrame<\/code> instance. Just call the appropriate method. Review the detailed <code>MapData<\/code> API documentation for more details.<\/p>\n<h3>Creating Your Data Series<\/h3>\n<p>Using Highcharts Maps for Python, you can configure your chart\u2019s data visualizations exactly the same as you would using any library in the Highcharts for Python toolkit. In general, your data can either reside in a CSV file, a Pandas <code>Dataframe<\/code>, a PySpark <code>Dataframe<\/code>, a GeoPandas <code>GeoDataFrame<\/code>, or even a Python list instance.<\/p>\n<p>Since we\u2019re focusing in this tutorial on Highcharts Maps for Python, let\u2019s assume we have a bunch of our map data in a GeoPandas <code>GeoDataFrame<\/code> instance called gdf. We can create our <code>MapSeries<\/code> or chart by calling <code>.from_geodataframe()<\/code> as shown below:<\/p>\n<pre># Given a geoPandas DataFrame instance named \"gdf\"\r\nfrom highcharts_maps.chart\r\nimport Chart\r\nfrom highcharts_maps.options.series.map\r\nimport MapSeries\r\n# Creating a Series from the GeoDataFrame\r\nmy_series = MapSeries.from_geopandas(gdf,\r\n  property_map = {\r\n    'id': 'state',\r\n    'name': 'state',\r\n    'value': 'value'\r\n  })\r\n# Creating a Chart with a MapSeries from the GeoDataFrame.\r\nmy_chart = Chart.from_geopandas(gdf,\r\n  property_map = {\r\n    'id': 'state',\r\n    'name': 'state',\r\n    'value': 'value'\r\n  },\r\n  series_type = 'map')<\/pre>\n<p>So what\u2019s happening in the code above? In the first example, we\u2019re creating a <code>MapSeries<\/code> instance by calling the <a href=\"https:\/\/maps-docs.highchartspython.com\/en\/latest\/api\/options\/series\/map.html#highcharts_maps.options.series.map.MapSeries.from_geopandas\" target=\"_blank\" rel=\"noopener\"><code>.from_geopandas()<\/code><\/a> class method on the <code>MapSeries<\/code> class. We\u2019re telling it to load the series data from the GeoPandas <code>GeoDataFrame<\/code> instance called <code>gdf<\/code>, and we\u2019re then providing it a <code>property_map<\/code> argument.<\/p>\n<p>This <code>property_map<\/code> argument is \u201cwhere the magic happens\u201d, since it maps columns of data in your <code>GeoDataFrame<\/code> to their corresponding properties in your <code>MapSeries .data<\/code> property (which takes a <code>GeometricData<\/code> instance).<\/p>\n<p>In this case, we\u2019re telling Highcharts Maps for Python to populate each data point\u2019s <code>.id<\/code> and <code>.name<\/code> properties (which give the data point a unique ID and specify the data point\u2019s label, respectively) from the <code>gdf<\/code> column labeled \u201cstate\u201d, and to populate the <code>.value<\/code> property from the column labeled \u201cvalue\u201d.<\/p>\n<p><i><b>Note<\/b><br \/>\nThe <code>.from_geopandas()<\/code> method is available on all <code>series<\/code> classes which support rendering as a map visualization. This includes:<\/i><\/p>\n<ul>\n<li><code>MapSeries<\/code><\/li>\n<li><code>MapBubbleSeries<\/code><\/li>\n<li><code>MapLineSeries<\/code><\/li>\n<li><code>MapPointSeries<\/code><\/li>\n<li><code>HeatmapSeries<\/code><\/li>\n<li><code>TilemapSeries<\/code><\/li>\n<\/ul>\n<p>Allowing you to either assemble a series or an entire chart from a GeoPandas <code>GeoDataFrame<\/code> with only one method call.<\/p>\n<h3>Other Approaches<\/h3>\n<p>The example above focuses on using a GeoPandas <code>GeoDataFrame<\/code>, but Highcharts Maps for Python has you covered regardless of how you are managing your data in your Python application. You have similar convenience functions for loading data:<\/p>\n<ul>\n<li><a href=\"https:\/\/maps-docs.highchartspython.com\/en\/latest\/api\/options\/series\/map.html#highcharts_maps.options.series.map.MapSeries.from_csv\" target=\"_blank\" rel=\"noopener\"><code>.from_csv()<\/code><\/a> which loads data from a CSV file.<\/li>\n<li><a href=\"https:\/\/maps-docs.highchartspython.com\/en\/latest\/api\/options\/series\/map.html#highcharts_maps.options.series.map.MapSeries.from_pandas\" target=\"_blank\" rel=\"noopener\"><code>.from_pandas()<\/code><\/a> which loads data from a Pandas <code>Dataframe<\/code>.<\/li>\n<li><code><a href=\"https:\/\/maps-docs.highchartspython.com\/en\/latest\/api\/options\/series\/map.html#highcharts_maps.options.series.map.MapSeries.from_pyspark\" target=\"_blank\" rel=\"noopener\">.from_pyspark()<\/a><\/code> which loads data from a PySpark <code>Dataframe<\/code>.<\/li>\n<\/ul>\n<p>You can call these convenience methods on the <code>Chart<\/code> class as shown above, or you can also call the exact same convenience methods on a series type, and then add the series to a chart instance using the <code><a href=\"https:\/\/maps-docs.highchartspython.com\/en\/latest\/api\/chart.html#highcharts_maps.chart.Chart.add_series\" target=\"_blank\" rel=\"noopener\">my_chart.add_series()<\/a><\/code> method.<\/p>\n<p><i><b>Tip<\/b><br \/>\nOur other tutorials show you in detail how to use these different convenience methods to rapidly build great visualizations \u2013 we recommend you check out here: Highcharts for Python Tutorials.<br \/>\n<\/i><\/p>\n<h3>Visualizing Your Chart<\/h3>\n<p>Now that we\u2019ve built a Chart instance and populated it with data, our next step is to visualize it. How you actually do this depends to some extent on how you are building your Python application.<br \/>\nMaybe you are using a web framework like Flask, Django, or FastAPI and relying on their templating engines for creating your views. Or maybe you are providing a Python backend API which delivers data to an entirely separate app via RESTful API calls. In any case, to visualize your new chart you need to somehow get its configuration to your web-based front-end. And that is super simple as well.<br \/>\nUsing the example above, you can generate the full set of HTML and JavaScript content to render your chart with one method call:<\/p>\n<pre>as_js_literal = my_chart.to_js_literal()\r\n# This will produce a string similar to:\r\n#\r\n# document.addEventListener('DOMContentLoaded', function() {\r\n#   const myChart = Highcharts.chart('target_div', {\r\n#      series: {\r\n#          type: 'map',\r\n#          data: [\r\n#              ['ny', 7],\r\n#              ['ma', 1],\r\n#              ['nj', 3]\r\n#      }\r\n#   });\r\n# });<\/pre>\n<p>So what is this method call doing? It is taking the entire set of instructions included in your <code>my_chart<\/code> variable, creating a JavaScript literal string that represents them, and putting that string in the <code>as_js_literal<\/code> Python variable. This string can then be piped into your web front end using whatever templating engine you are using, or delivered to your front-end in an API response, and it will then render your chart as you configured it.<br \/>\nIn the example above, if you place the <code>as_js_literal<\/code> string in what gets rendered in your user\u2019s browser, your chart will be automatically rendered by <a href=\"https:\/\/www.highcharts.com\/products\/maps\/\" target=\"_blank\" rel=\"noopener\">Highcharts Maps<\/a>, placing the chart inside the <code>div<\/code> element in your content whose id is <code>\u201ctarget_div\u201d<\/code>.<br \/>\nAnd that\u2019s it! You should now see a beautiful map chart in your web content.<\/p>\n<h3>Downloading Your Chart<\/h3>\n<p>Often when you\u2019ve created a visualization, you may want to download a static version of it as an image that can be embedded in other documents. With Highcharts Maps for Python, that is a fairly trivial exercise. Given the example above, you can produce a PNG image very simply with one method call:<\/p>\n<pre># Download a PNG version of the chart in memory within your Python code.\r\nmy_png_image = my_chart.download_chart(format = 'png')\r\n# Download a PNG version of the chart and save it the file \"\/images\/my-chart-file.png\"\r\nmy_png_image = my_chart.download_chart(\r\n  format = 'png',\r\n  filename = '\/images\/my-chart-file.png'\r\n)<\/pre>\n<p>The two examples shown above both download a PNG of your chart:<br \/>\nThe first example keeps that PNG image in your Python code only, storing its binary data in the <code>my_png_image<\/code> variable. The second example not only stores its binary data in the <code>my_png_image<\/code> variable, but it also saves the PNG image to the file <code>\u201c\/images\/my-chart-file.png\u201d<\/code>.<\/p>\n<p>The <code>format<\/code> argument is really the one doing the heavy lifting above. In the example above tells the method to generate a PNG image, but you can also create <code>\u201cjpeg\u201d<\/code>, <code>\u201cpdf\u201d<\/code>, and <code>\u201csvg\u201d<\/code>.<\/p>\n<p>And that\u2019s it! You should know that the <code><a href=\"https:\/\/maps-docs.highchartspython.com\/en\/latest\/api\/chart.html#highcharts_maps.chart.Chart.download_chart\" target=\"_blank\" rel=\"noopener\">.download_chart()<\/a><\/code> method defaults to using the Highcharts Export Server provided by Highsoft (creators of <a href=\"https:\/\/www.highcharts.com\" target=\"_blank\" rel=\"noopener\">Highcharts JS<\/a>), however you can configure the method to use your own <a href=\"https:\/\/www.highcharts.com\/docs\/export-module\/setting-up-the-server\" target=\"_blank\" rel=\"noopener\">custom Highcharts Export Server<\/a> if you choose. For more details on how to do this, please review our tutorial on <a href=\"https:\/\/www.highcharts.com\/blog\/tutorials\/exporting-static-charts-highcharts-python\" target=\"_blank\" rel=\"noopener\">Exporting Static Charts using Highcharts for Python<\/a>.<\/p>\n<h3>More Resources<\/h3>\n<p>The above tutorial is just a really simple example of how you can create rich visualizations with just a handful of method calls using Highcharts for Python. But the library offers so much more! We recommend you take a look at the following additional resources which you may find useful:<\/p>\n<ul>\n<li><a href=\"https:\/\/www.highcharts.com\/blog\/tutorials\/using-highcharts-for-python-basic-tutorial\" target=\"_blank\" rel=\"noopener\">Highcharts for Python: Tutorials<\/a><\/li>\n<li><a href=\"https:\/\/www.highcharts.com\/blog\/tutorials\/highcharts-maps-python-asynchronous-map-data\" target=\"_blank\" rel=\"noopener\">Highcharts Maps for Python &#8211; Working with Asynchronous Map Data <\/a><\/li>\n<li><a href=\"https:\/\/www.highcharts.com\/blog\/tutorials\/exporting-static-charts-highcharts-python\" target=\"_blank\" rel=\"noopener\">Exporting Static Charts using Highcharts for Python<\/a><\/li>\n<li><a href=\"https:\/\/www.highcharts.com\/blog\/tutorials\/templating-and-shared-options-highcharts-python\" target=\"_blank\" rel=\"noopener\">Using Templating and Shared Options in Highcharts for Python <\/a><\/li>\n<li><a href=\"https:\/\/maps-docs.highchartspython.com\/en\/latest\/\" target=\"_blank\" rel=\"noopener\"> Highcharts for Python: API Reference Documentation<\/a><\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"<p>A step-by-step tutorial to learn how to create a python map with Highcharts Maps<\/p>\n","protected":false},"author":273,"featured_media":23576,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"meta_title":"","meta_description":"","hc_selected_options":[],"footnotes":""},"categories":[1105],"tags":[876,885],"coauthors":[983],"class_list":["post-23406","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-integration","tag-highcharts-maps","tag-python"],"_links":{"self":[{"href":"https:\/\/www.highcharts.com\/blog\/wp-json\/wp\/v2\/posts\/23406","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.highcharts.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.highcharts.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.highcharts.com\/blog\/wp-json\/wp\/v2\/users\/273"}],"replies":[{"embeddable":true,"href":"https:\/\/www.highcharts.com\/blog\/wp-json\/wp\/v2\/comments?post=23406"}],"version-history":[{"count":1,"href":"https:\/\/www.highcharts.com\/blog\/wp-json\/wp\/v2\/posts\/23406\/revisions"}],"predecessor-version":[{"id":29382,"href":"https:\/\/www.highcharts.com\/blog\/wp-json\/wp\/v2\/posts\/23406\/revisions\/29382"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.highcharts.com\/blog\/wp-json\/wp\/v2\/media\/23576"}],"wp:attachment":[{"href":"https:\/\/www.highcharts.com\/blog\/wp-json\/wp\/v2\/media?parent=23406"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.highcharts.com\/blog\/wp-json\/wp\/v2\/categories?post=23406"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.highcharts.com\/blog\/wp-json\/wp\/v2\/tags?post=23406"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.highcharts.com\/blog\/wp-json\/wp\/v2\/coauthors?post=23406"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}