---
title: "Google Slides integration for AI agents | Langdock"
description: "Connect Google Slides to Langdock. Agents and workflows can use 38 actions, such as “Add image” and “Add line”."
url: "https://langdock.com/integrations/google-slides"
language: "en"
---

[Integrations](https://langdock.com/products/integrations)

# Google Slides integration for AI agents

Build and edit presentations with slides, shapes, and images

Connect Google Slides to Langdock and use it in chat, in agents and in workflows.

38 actions

[Start free trial](https://app.langdock.com/signup) [Talk to sales](https://langdock.com/talk-to-sales)

## Google Slides actions

Each action is one step an agent or workflow can run in Google Slides.

- Add image

  Inserts an image from a publicly accessible URL onto a slide at a given position and size. Use it to add logos, photos, charts, or other pictures to an existing slide. Requires the target presentationId and the slide's object ID (slideId); returns the created image's object ID as imageId, which you can reference in later calls to move, resize, or replace the image.
- Add line

  Draws a line, arrow, or connector on a slide. Use it to add a straight/bent/curved line, a directional arrow, or a connector that visually links two existing shapes. Provide the slide's object ID (from get_presentation or a create action) as slideId; the line's own object ID is returned as lineId for later reference. To connect endpoints to shapes, pass those shapes' existing object IDs in startConnectionId/endConnectionId.
- Add shape with text

  Creates a shape or text box (optionally pre-filled with text) on a specific existing slide; use it to add text content, containers, callouts, arrows, or diagram elements to a deck. ID flow: takes the presentation's ID and the target slide's OBJECT ID (not its number), and returns the created shape's object ID as shapeId — capture it to format, move, or modify the shape in later calls.
- Add table

  Creates a new table with the given rows/columns at a position on a slide, optionally pre-filling and formatting cells via initialData in one call. Use it to add comparison/data grids to a deck. Needs the presentationId and the target slide's object ID; returns the created table's object ID (tableId) — pass that to later actions (e.g. updating cells or styling) to reference this table.
- Batch update (advanced / raw API)

  Power escape hatch: send a raw array of Google Slides API requests in one ATOMIC presentations.batchUpdate call. Use this ONLY for advanced or rarely-needed operations the dedicated actions (Create slide, Add table, Add image, Add shape with text, Edit shape text, Replace text, Update text style, Update paragraph style, Update shape properties, Update element transform, Add line, Duplicate object) do NOT cover - e.g. reordering or deleting slides (updateSlidesPosition, deleteObject), grouping/ungrouping, bullet/numbered lists (createParagraphBullets), z-ordering (updatePageElementsZOrder), merging table cells, recoloring images, embedding Sheets charts (createSheetsChart), updating slide/page background or page properties, or any brand-new request type. Prefer the dedicated actions when one fits. ID flow: every request that targets an EXISTING slide or element (its 'objectId' / 'pageObjectId') needs that element's exact opaque object ID - get it from get_presentation (outputFormat 'map' for a compact slideId index, or 'json'), or from the id returned by the action that created it; NEVER pass a slide number or an invented name. To name a NEW object yourself, set 'objectId' inside the create request (5-50 chars of letters/digits/'_'/'-'/':', not starting with a digit, unique in the deck); omit it to auto-generate. IMPORTANT: batchUpdate is ATOMIC - if any single request is invalid the ENTIRE batch is rejected and NOTHING is applied (the deck stays unchanged), so fix the one bad request and resend the whole batch. The response returns the raw replies plus a positional reply summary and a map of newly-created object IDs (requestIndex to resulting objectId) so you can chain follow-up requests without a separate GET. PREFER the dedicated actions for common edits (e.g. update_slide_background, update_z_order, update_shape_properties, update_table, create_slide, add_image) — they build the exact Slides API request for you; use batch_update only for operations without a dedicated action or to apply many edits in one atomic call. Schema notes: a solidFill color takes rgbColor directly (NO 'opaqueColor' wrapper), and updatePageElementsZOrder uses 'pageElementObjectIds' (not 'pageObjectIds'). These two common mistakes are auto-corrected, but other request fields must match the Google Slides API exactly.
- Build deck from outline

  Build every slide in an outline into an existing presentation in one call. Use create_slide to add a single slide. Create the presentation first with create_presentation. Later edits should use the slide and placeholder IDs this action returns.
- Copy presentation

  Duplicates an existing Google Slides presentation into a new file (optionally renamed and placed in a specific Drive folder); use it to clone a deck before editing or to spin up a copy from a template. Returns the new presentation's ID as newPresentationId — pass that ID to subsequent actions (get_presentation, create_slide, etc.) when working on the copy.
- Create presentation

  Create a new blank Google Slides presentation (with one default slide) and optionally place it in a specific Drive folder; use this to start a new deck before adding slides or content. Returns the new presentationId (the ID needed by every other Google Slides action) plus the object ID of the initial slide, so capture them from the result and pass them to later calls rather than guessing.
- Create slide

  Add a new slide to a presentation with a chosen layout and, optionally, fill its title and body placeholders in the same step (no separate text action needed). Use it whenever you need to insert a slide into an existing deck. IDs: pass the target presentation's ID in presentationId; the action RETURNS the new slide's object ID (slideId) plus the auto-assigned title and body placeholder object IDs (titlePlaceholderId, bodyPlaceholderId, placeholderIds), which you should reuse to style or further edit those elements without re-fetching the presentation.
- Create video

  Embeds a YouTube or Google Drive video onto a slide in one step; use it to add a video player (YouTube is the common case) to an existing slide. ID flow: pass the target slide's OBJECT ID in slideId (not its number) and the presentation's ID in presentationId; the video's source id goes in `id`. Returns the created video element's object ID (as both objectId and videoObjectId) so you can immediately reposition, resize, or delete it without re-fetching the presentation.
- Delete object

  Permanently deletes one or more slides and/or page elements (shapes, text boxes, images, tables, lines, charts) from a presentation by their object IDs, in a single atomic batch. Use it to undo or fix mistakes - e.g. remove a wrongly placed image, an extra slide, or a stray text box; deleting a slide also removes every element on it. Every ID you pass must be the exact object ID of something that already exists: get slide object IDs from get_presentation with outputFormat "map" (or the slideId/slideIds returned by create_slide / build_deck_from_outline), and element object IDs from the create_* action that made the element or from get_presentation (outputFormat "map" or "json"). Never invent an ID or pass a slide number. The batch is atomic: if any ID is invalid or missing, the whole call is rejected and nothing is deleted.
- Duplicate slide or element

  Duplicate an existing slide (with all its content) or a single page element (shape, text box, table, image, or line) within the same presentation; the copy is inserted directly after the original. Use it for templating - build one polished slide, then duplicate it per section and customize each copy. ID flow: pass the OBJECT ID of the slide/element to duplicate (from get_presentation or the action that created it). The API auto-generates new IDs for the copy and its children and only returns the new top-level ID, so optionally supply idMappings to assign your own predictable IDs and edit the copy immediately without a follow-up get_presentation. Returns the new top-level object ID plus the full old-to-new ID map.
- Edit shape text

  Edits the text of an existing shape, text box, or table cell on a slide — replace all text, replace a specific character range, or insert text at a position. Use it to fill placeholders or update copy after a shape exists. You must pass the element's exact object ID in `elementId`: get it from the action that created the element (add_shape_with_text, add_table, etc., which return the id they used) or from get_presentation (outputFormat "map" or "json"). Never invent an ID and never pass a slide number.
- Edit speaker notes

  Write, append to, or clear the speaker notes for one slide (the presenter-facing 'Notes' area below the slide), not the visible on-slide text. Use it to draft what the presenter should say, add talking points to a slide you just created, or wipe outdated notes. Operates on a single slide identified by its slide OBJECT ID. ID flow: pass the presentationId from the URL and the slide's objectId (from create_slide / build_deck_from_outline output, or get_presentation outputFormat 'map'); the action automatically locates the speaker-notes shape on that slide, so you never supply the notes shape ID yourself.
- Embed Sheets chart

  Embed an existing chart from a Google Sheets spreadsheet onto a slide as either a LINKED chart (stays connected to the Sheet so it can be refreshed with the latest data) or a NOT_LINKED_IMAGE (a static, non-refreshable snapshot). Use it to drop a Sheets-built chart into a deck instead of recreating the data in Slides. You must have at least view access to the source spreadsheet (the Slides API reads it on your behalf). ID flow: pass the presentationId from the URL, the slide's OBJECT ID (not its number — get it from get_presentation outputFormat "map", or from create_slide / build_deck_from_outline), the spreadsheetId, and the INTEGER chartId from inside that Sheet (0, 1, 2, …) — NOT a Slides object ID. Returns the embedded chart's object ID (objectId / chartObjectId) and whether it is linked, so you can later refresh, move, resize, or delete it.
- Export presentation

  Export an entire Google Slides deck as a downloadable file and return it to the user — PDF (preserves exact layout/visuals; best for sharing or printing), PPTX (editable PowerPoint), or TXT (plain-text extraction of all slide text). Use this when the user wants to download, save, share, or convert a whole deck. The file is named after the presentation title (e.g. 'My Deck.pdf'). This action consumes only the presentationId (no slide or element IDs); take the presentationId from the URL or from the presentationId returned by create_presentation / copy_presentation. Note: Google's Drive export endpoint caps exports at 10MB — very large decks return an actionable error suggesting TXT or a manual download.
- Get presentation

  Read a Google Slides presentation's content as a slide map, full JSON, markdown, or plain text. This is the primary way to discover the OBJECT IDs you need for every edit: use outputFormat "map" to get a compact, ID-annotated index (per slide: slideId, layout, title, hasBody, and elementIds), then pass those exact IDs to edit/create actions. Use it before editing to locate slides and elements by ID, and after editing to verify the result. Never guess IDs or use slide numbers — read them from here.
- Group objects

  Combine two or more existing page elements on the SAME slide (shapes, text boxes, images, lines, word art) into a single group so they move, scale, rotate, and delete together as one unit. Use it to keep related elements locked together (a logo plus its caption, a chart plus its labels) so they stay aligned during later edits. ID flow: you pass the object IDs of elements that ALREADY exist (each create action returns the id it used; get_presentation also lists them), and this action RETURNS the new group's objectId — use that returned id as the chainable handle for follow-up actions (e.g. update_element_transform to move the whole group, or delete_object to remove it). Videos, tables, and placeholders CANNOT be grouped, and all children must be on the same slide and not already part of another group.
- List layouts

  Inspect a presentation's theme and layout catalog before creating or editing slides. For every layout it returns the predefinedLayout name (the exact value create_slide expects in its layout/predefinedLayout field — e.g. TITLE_AND_BODY), a human display name, and the placeholder types and indices that layout offers (e.g. TITLE[0], BODY[0]) so you never target a placeholder that doesn't exist. Also returns the master's theme color scheme as hex, the slide dimensions (pageSize) in points, and — when the master's placeholder shapes carry styling — the default fonts/styles per placeholder type (defaultTextStyles may be empty for decks whose master placeholders are blank prompt shapes). This action reads only; it consumes a presentationId and produces no object IDs you must thread into later calls — its purpose is to tell you which predefinedLayout names and placeholder slots are valid inputs for create_slide. Use it first whenever you need to know which layouts exist, what placeholders a layout has, or what colors/fonts the theme uses.
- List presentations

  Find Google Slides presentations the user can access, returning each one's presentationId, name, last-modified/created time, owners, and links. Use it to discover a deck before reading or editing it. This is the entry point for the ID chain: the returned presentationId (the alphanumeric ID in a deck's URL between '/d/' and '/edit') can be passed directly to get_presentation, create_slide, and other Slides actions — so call this first instead of guessing a presentationId. It does not read slide contents or slide/element object IDs; use get_presentation (outputFormat "map") for those.
- Refresh linked chart

  Re-fetches a linked Google Sheets chart embedded on a slide and updates its image in place so it reflects the current spreadsheet data; use it after the source Sheet's data changes (e.g. to refresh a revenue or KPI chart before presenting). Only charts inserted with a live spreadsheet link (linkingMode LINKED) can be refreshed - a chart pasted as a static image is not linked and returns an actionable error. The chart's objectId is unchanged by the refresh, so it stays addressable for follow-up calls. ID flow: supply the presentationId from the URL and the chart's objectId, which you get from the action that inserted the chart (it returns the id it used) or from get_presentation - never invent or guess it.
- Render slide

  Renders a slide (or the whole deck) to a PNG image and returns a temporary image URL, width, and height per slide — use it after creating or editing slides to visually verify layout, overflowing text, overlapping elements, colors, and alignment before considering the deck done. Consumes existing IDs only: pass the presentationId from the deck's URL and, optionally, real slide OBJECT IDs (not slide numbers). Leave the slide ID empty to render every slide in order; the contentUrl links it returns expire ~30 minutes after rendering, so view them promptly or re-run.
- Reorder slides

  Move one or more existing slides to a new position in a deck (e.g. pull the agenda to slide 2, push an appendix to the end). The slides are identified by their slide OBJECT IDs and moved together as a contiguous block, preserving the relative order you list them in. ID flow: get presentationId from the deck URL, and get each slideId from get_presentation (outputFormat "map" gives a compact slideId index) or from the slideId/slideIds returned by create_slide or build_deck_from_outline — never use a slide number/position. Returns the full new slide order so you can verify the result without a follow-up read.
- Replace image

  Swap an existing image element on a slide for a new image URL, in place: the element keeps its exact size, position, and objectId — only the underlying picture changes. Use it to update what an existing image shows (refresh a logo, swap a product photo, update a screenshot); use Add image instead to create a new image at coordinates you specify, or Replace shapes with images to match shapes by placeholder text. CENTER_INSIDE fits the new image inside the original frame keeping aspect ratio (default); CENTER_CROP fills the frame and may crop. ID flow: pass the image's existing object ID in imageObjectId — get it from the id returned by add_image (or from get_presentation with outputFormat "map"/"json"); the same objectId is returned so you can chain further edits to that element.
- Replace shapes with chart

  Replaces every placeholder shape whose visible TEXT matches a token (e.g. '{{revenue_chart}}') with a chart pulled from a Google Sheet. Use it to fill template-driven decks where chart placeholders are typed into text boxes ahead of time; pairs with replace_text and replace_shapes_with_images to fully populate a templated slide. The token is matched against shape text, NOT shape object IDs or names, so no element IDs are needed here — only the presentationId, the source spreadsheetId, and the integer chartId. Choose LINKED (default) so the chart can later be refreshed with the latest Sheet data, or NOT_LINKED_IMAGE for a static snapshot. Returns occurrencesChanged (how many placeholders were filled). For LINKED charts the API does NOT return the new chart's objectId, so to refresh it later you must run get_presentation to find the SheetsChart element's objectId. If the token isn't in the deck yet, insert it first with replace_text.
- Replace shapes with images

  Replaces every placeholder shape in a presentation with an image, by matching the shape's TEXT content (e.g. {{company-logo}}) rather than its object ID. Use it to fill image placeholders across a deck in one batch call (e.g. after build_deck_from_outline / create_slide laid out branded templates with {{...}} tokens). Takes the presentationId plus a list of placeholder-text-to-image-URL mappings; it does NOT take slide or shape object IDs - targeting is purely by the literal text inside the shapes. Returns the count of shapes replaced (totalReplacements) and a per-placeholder breakdown (replacementDetails); a result of 0 means the placeholder text was not found verbatim in any shape.
- Replace text

  Find-and-replace text across a presentation in one batch — ideal for filling template placeholders (e.g. {{customer-name}}, {{date}}) with real values for mail-merge or generated decks. Pass each search/replace pair in textReplacements; optionally scope a replacement to specific slides via that pair's pageObjectIds (slide OBJECT IDs, not slide numbers). Returns occurrencesChanged per pair so you can confirm what was actually replaced. Requires the presentationId; if you also need slide object IDs, get them from get_presentation (outputFormat "map") or from create_slide / build_deck_from_outline.
- Set element alt text

  Set the accessibility alt text (title and/or description) on a single existing page element - an image, shape, table, line, group, chart, or video - so screen readers and accessibility/compliance checks (WCAG, Section 508) can describe it. Use this after creating or locating an element to make a deck accessible. Identify the element by its exact objectId: every create-element action returns the id it used (e.g. 'Add image' imageId, 'Add shape with text' shapeId, 'Add table' tableId), or look it up with 'Get presentation' (outputFormat 'map' or 'json'); never invent or guess an id. Provide a title and/or a description - passing an empty string ("") clears that field while omitting it leaves it unchanged; at least one is required. Alt text applies only to page ELEMENTS, never to slides/pages. Echoes back the objectId so you can chain further edits on the same element.
- Set image outline and link

  Sets the border (outline) and/or clickable link of an existing image on a slide, in place, without replacing the picture — use it to frame an image, recolor/restyle its border, or make it link to a URL. Outline controls: color (RGB 0-1), weight (thickness in points), dash style, and transparency; link controls: point the image at an http(s) URL or pass an empty string to remove the link. Only the properties you set are changed (the API field mask is built to match), so unset fields are left untouched. Identify the image by the exact object ID of an image element that already exists — get it from the response of the action that created it (e.g. 'Add image' returns the imageId) or from 'Get presentation'; never invent or guess the ID. Note: the Slides API does NOT allow setting image effects (brightness, contrast, transparency of the picture itself, recolor filters like grayscale/sepia, or cropping) — those are read-only. To swap the picture, use 'Replace image'; to move or resize it, use 'Update element transform'.
- Set slide background

  Set a single slide's background to a solid color, a stretched image, or inherit it from the slide's layout/master. Use when restyling one slide's backdrop (not a shape's fill — use 'Update shape properties' for that; use 'Add image' to place a movable picture). Choose backgroundType: SOLID_COLOR fills the slide with one RGB color (0-1 per channel) plus optional transparency; IMAGE stretches a public http(s) image to cover the slide; INHERIT_FROM_PARENT removes this slide's own background so it falls back to its layout/master. ID flow: pass the target slide's page object ID in slideId (NOT the slide number). Only the background changes; the field mask is built automatically and the update is atomic (on failure the slide is left unchanged). Returns the same slide object ID under both slideId and objectId so follow-up actions can chain off it.
- Ungroup objects

  Ungroup one or more grouped page elements ('elementGroup') back into their individual child elements; pass an array to ungroup many in one atomic batchUpdate. After ungrouping, each child (shape, text box, image, line, etc.) becomes an independent page element and keeps its existing child objectId, so you can then move, resize, restyle, or delete the pieces separately — for example to reposition just one element of a logo lockup. ID flow: the group objectIds you pass must be real existing group IDs — get them from get_presentation (outputFormat 'map' or 'json'), where groups appear as 'elementGroup' elements listing their child objectIds, or from the id returned by the group action that created them. Do NOT invent IDs. The group IDs cease to exist after the call; to address the now-independent children, re-read them via get_presentation (outputFormat 'map').
- Update element transform

  Move, resize, rotate, or shear an existing page element (shape, image, text box, line, group, etc.) on a slide by updating its transform matrix. Use it to reposition or scale elements after creating them or after reading the current layout. Requires the object ID of an element that already exists — get it from the action that created the element (every create action returns the id it used) or from get_presentation (outputFormat "map" or "json"). Never invent or guess the element ID.
- Update element z-order

  Reorder one or more page elements front-to-back (z-order / stacking order) on a single slide, choosing an operation: BRING_TO_FRONT, BRING_FORWARD, SEND_BACKWARD, or SEND_TO_BACK. Use it to fix overlap - e.g. put a label on top of an image, push a background shape behind text, or bring a highlighted box to the front. All listed elements move together in one atomic batch. This action consumes existing element object IDs: pass the exact objectId of each element (from the create action that returned it, or from get_presentation with outputFormat "map" or "json") - never invent IDs or pass a slide number. Every element must be on the SAME slide and must not be grouped; whole slides and layout-inherited placeholders cannot be reordered. If any ID is wrong the whole batch is rejected and nothing moves.
- Update line properties

  Restyle an EXISTING line, arrow, or connector by changing only the properties you set: color, thickness, dash pattern, arrowheads, or transparency (everything else is left untouched). Use it to edit a line you already added with 'Add line' or any line found in the deck. It does NOT create lines ('Add line') and does NOT move or re-route endpoints ('Update element transform'). ID flow: pass the presentationId from the deck URL plus the line's existing objectId — use the id returned by 'Add line', or look it up via 'Get presentation' (outputFormat "map" or "json"). Never invent or mistype an object ID. The action echoes the line's objectId (as both objectId and lineId) so you can chain further edits.
- Update paragraph style

  Formats existing paragraphs in a shape or text box (alignment, line spacing, indentation, space above/below, bullets/numbered lists, and text direction); use it to style copy after the text already exists. Requires two existing IDs: the presentationId from the deck URL and the elementId of the shape/text box. Get elementId from the id returned when the element was created (add_shape_with_text, build_deck_from_outline, etc.) or from get_presentation (outputFormat "map" or "json"); never invent or guess it.
- Update shape properties

  Restyle an existing shape's appearance — background fill color/transparency, outline color/weight/dash-style/transparency, and content alignment — in one batch update; use it to polish a shape created by 'Add shape with text' (or any existing shape). Targets an existing shape, so it consumes IDs but creates none: pass the presentationId and the shape's objectId. Supply at least one styling field; fields left blank are unchanged.
- Update table

  Edits an existing table in a Google Slides presentation in one call: choose ONE operation via the 'operation' field (insert/delete rows or columns, merge/unmerge cells, set cell background fill, set column widths or row heights, or style cell borders) and supply only the inputs that operation needs. Use it after a table already exists (added via 'Add table'). It is index-driven, not ID-driven beyond the table itself: pass the table's object ID plus zero-based row/column indices, never the cell text or a slide number. The presentation is left unchanged if any input is invalid. On success the table's object ID is echoed back so you can chain further edits without re-fetching.
- Update text style

  Formats existing text and/or inserts/replaces text in a shape, text box, or table cell — applying character styles (bold, italic, color, font, size, link, etc.), paragraph styles (alignment, spacing, indentation), and bullet/numbered list formatting. Use after a deck's text elements exist to style or rewrite their content. ID flow: this action consumes the existing element's object ID via objectId — it does not create or return a new element ID. Get objectId from the create action that made the element (add_shape_with_text, add_table, etc. return the id they used) or from get_presentation (outputFormat "map" or "json"); never invent or guess it.

## Setup and permissions

An action can ask for your confirmation before it runs. In an agent, each action is set to “Always allow” or “Needs approval”.

### Documentation

- [Using integrations](https://docs.langdock.com/en/using-langdock/guides/integrations/using-integrations)
- [How connections work](https://docs.langdock.com/en/using-langdock/integrations/connections)
- [Manage access to actions](https://docs.langdock.com/en/admin/manage-integrations/manage-action-access)

[All integrations](https://langdock.com/products/integrations)
