# Show base64 images in Power BI, even beyond 32,766 characters

> Get started with Image Plume: prepare a table of base64 images, split long images into chunks, insert the visual, pick size, position and a round mask.

- Language: English
- Web page: https://plumevisuals.com/en/tutorials/image-plume-prise-en-main
- Published: 2026-10-21
- Visual: Image Plume, technical reference: https://plumevisuals.com/ai/visuals/image.md
- If an option name in this tutorial differs from the technical reference, the reference is right (it is generated from the visual's code).

## In short

**What is a base64 image?** An image (PNG, JPEG, SVG…) can be written as a long text: that is **base64**. With `data:image/png;base64,` in front, the text becomes a **data URI**, which the visual shows without downloading anything. Images then travel inside the Power BI model: they show offline, in a PDF export and in the service, with no link to a website and no access rights to manage.

A tiny example. Your company's 3 KB logo becomes a text of about 4,000 characters; a 60 KB photo, a text of about 80,000 characters. Power BI cuts every column text at **32,766 characters**: the photo must be split into three chunks, which the visual joins back.

- **What the visual does.** Image Plume shows the base64 images of a column or a measure, one image or a gallery (one image per product, place or person), joins images split into chunks, positions and sizes the image, clips it to a shape (rounded corners, circle, 153 shapes or your SVG ★), sets the opacity, brightness and contrast, and filters the report on click.
- **When to use it.** Product photos, customer or store logos, portraits, status icons, floor plans, before / after pictures, a slideshow from one year to the next.
- **When to use something else.** A fixed image that never changes: the native Image visual is enough (if a web address or an upload is fine for you). An icon inside a table cell: Table Plume.
- **What you will be able to do.** Prepare a table of images, split long images, insert the visual, show a gallery, pick the size and position, turn images into circles.
- **What you need:** Power BI Desktop, the Image Plume visual installed (see [the shared basics](/en/tutorials/bien-demarrer-visuels-plume)), a few images. The **PlumeImage-Sample-EN** sample report, in your [Downloads](/en/account/downloads) area, shows 8 places as a gallery and as a featured image (page 1), a slideshow by year, round portraits and shapes (page 2), and the ★ features: carousel, before / after, light by score, filters, magnifier (page 3).

## The data to provide

**The shape.** One row per image: a **key** (the name of the product, the place…), the base64 text of the image and, if you like, a caption. An image longer than 32,766 characters takes **several rows**: one per chunk, with its number in a **Chunk index** column.

| Place | Chunk index | Image | Caption |
|---|---|---|---|
| Arcachon | 1 | `iVBORw0KGgoAAAANSUhEUgAA…` (30,000 characters) | Bay and stilt huts |
| Arcachon | 2 | `…rest of the image…` | Bay and stilt huts |
| Arcachon | 3 | `…end of the image…` | Bay and stilt huts |
| Sarlat | 1 | `iVBORw0KGgoAAAANSUhEUgAA…` | Medieval town |
| Sarlat | 2 | `…end of the image…` | Medieval town |

**Load a folder of images with Power Query.** **Home › Get data › Folder**, pick the folder of your images, then **Transform data** and, in **Home › Advanced editor**, replace the query with:

```m
let
    Source   = Folder.Files("C:\Images"),
    Bin      = Table.AddColumn(Source, "B64", each Binary.ToText([Content], BinaryEncoding.Base64), type text),
    // 30,000-character chunks: below the 32,766 limit of Power BI texts
    Chunks   = Table.AddColumn(Bin, "Chunks", each
                 let t = [B64], n = Number.RoundUp(Text.Length(t) / 30000)
                 in  Table.FromColumns({ {1..n}, List.Transform({0..n - 1}, (i) => Text.Middle(t, i * 30000, 30000)) },
                                       { "Chunk index", "Chunk" })),
    Keep     = Table.SelectColumns(Chunks, { "Name", "Chunks" }),
    Rows     = Table.ExpandTableColumn(Keep, "Chunks", { "Chunk index", "Chunk" }),
    Types    = Table.TransformColumnTypes(Rows, { { "Chunk index", Int64.Type }, { "Chunk", type text } })
in
    Types
```

You get a table with `Name` (the file name: the key), `Chunk index` and `Chunk`. The base64 is "raw" (without `data:image/png;base64,`): the visual recognizes the image type from its first bytes.

**To try without a file.** **Modeling › New table**, then paste (two SVG icons, short enough to fit on one row each):

```dax
Icons =
DATATABLE (
    "Status", STRING, "Image", STRING,
    {
        { "OK", "data:image/svg+xml;base64,PHN2ZyB4bWxucz0naHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmcnIHZpZXdCb3g9JzAgMCAxMDAgMTAwJz48Y2lyY2xlIGN4PSc1MCcgY3k9JzUwJyByPSc0NicgZmlsbD0nIzJFN0Q0RicvPjwvc3ZnPg==" },
        { "Alert", "data:image/svg+xml;base64,PHN2ZyB4bWxucz0naHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmcnIHZpZXdCb3g9JzAgMCAxMDAgMTAwJz48Y2lyY2xlIGN4PSc1MCcgY3k9JzUwJyByPSc0NicgZmlsbD0nI0MwMzkyQicvPjwvc3ZnPg==" }
    }
)
```

**Pitfalls.**
- A **web address** (`https://…/logo.png`) is never loaded: it is a Microsoft certification rule (no network request). The visual says so in edit mode; convert the image to base64.
- Without **Chunk index**, Power BI keeps only the first 32,766 characters: the image is cut or unreadable.
- The image column can go into **Image** as it is (no sum or "First" to pick); a measure that returns the image text works too.
- One key per image: without **Image key**, all the chunk rows form a single image.

## Step by step: your first gallery in 10 minutes

1. In the **Visualizations** pane, click the **Image Plume** icon. An empty frame appears, with a landing page that lists the fields to drop.
2. Drag the `Chunk` (or `Image`) column into **Image (base64)**. A first image shows, maybe cut if it is long.
3. Drag `Chunk index` into **Chunk index**: the whole image shows.
4. Drag `Name` (or `Place`) into **Image key (category)**: the visual shows the first image; this is the **Single image** mode, which follows the report filters.
5. Open **Format › Layout › Display** and pick *Grid (gallery)*: one cell per image, with the key as a caption under each image.
6. In **Format › Position and size › Size**, pick *Fill (crop)*: every cell is full; the **Position** picks the part of the image that stays visible.
7. In **Format › Mask (clipping)**, pick *Ellipse or circle*: each image becomes a circle.
8. In **Format › Outline and shadow**, turn on **Outline**, set **Width (px)** = 3 and **Color (empty = accent)** = white: the outline follows the circle.
9. Click an image: the other visuals of the page are filtered on this key (cross-filtering, see the [glossary](/en/tutorials/bien-demarrer-visuels-plume#glossary)) and the other images fade. Click an empty area of the visual to undo.
10. Hover an image: the tooltip gives the key, the **Tooltips** fields and the image size in pixels.

**Expected result:** a gallery of your images as circles with an outline, a caption under each one, filtering the page on click, with no watermark (all these features are free).

## Troubleshooting

| What you see | Likely cause | Fix |
|---|---|---|
| Image cut at the bottom or a gray placeholder | Text truncated at 32,766 characters | Split into chunks and add **Chunk index** |
| "Embedded images only: web addresses are never loaded" | The column holds http(s) addresses | Convert the images to base64 (Power Query above) |
| "Unrecognized image" | The text is not an image (space, quotes, other format) | Check the column; accepted formats: PNG, JPEG, GIF, WebP, BMP, SVG |
| One image instead of a gallery | *Single image* mode, or no **Image key** | **Format › Layout › Display** › *Grid (gallery)* and add the key |
| All images mixed into one | Chunks of several images with no key | Add the key (file name) to **Image key (category)** |
| "Missing chunks for …" in edit mode | A chunk number is missing (filter, deleted row) | Check the table: the numbers must follow each other |
| "+N images not shown" | More images than **Maximum number of images** | Raise the setting (500 at most) or filter |
| "Premium preview" watermark | A ★ feature is used without a key | Key in Format › Plume Studio License, or a free setting |

## Key takeaways

- Base64 images or data URIs only: no web address, so everything shows offline and in PDF.
- Beyond 32,766 characters: one row per chunk and the **Chunk index** field.
- **Image key** = one image per value, click to filter, gallery.
- Position, size, circle, 22 shapes, outline, opacity, brightness, contrast, grayscale: free; slideshow (play axis), shadow, saturation, blur, rotation and flips: ★.

## Going further

- [Image Plume use cases](/en/tutorials/image-plume-cas-pratiques): default logo, slideshow, before / after, image by score and more recipes.
- [Image Plume fields and settings](/en/tutorials/image-plume-champs-et-reglages): every field well and every setting.
- [Getting started with Plume visuals](/en/tutorials/bien-demarrer-visuels-plume): installation, license, styles and shared settings.
- The visual's page: [Image Plume](/en/visuals/image). A question: [support](/en/support).