.png)
Google Slides Integration Guide
Connect Google Slides with enterprise systems through its REST API, Google Drive operations, OAuth authorization, and selected Drive change notifications.
Google Slides integration options at a glance
Google Slides provides a REST API over HTTPS with JSON payloads for retrieving presentations, reading slides and page elements, and creating or modifying presentation content. The Slides API supports grouped mutations through batchUpdate, while Google Drive APIs handle file metadata, copying, permissions, exports, downloads, and supported change notifications. OAuth 2.0 is the primary authorization model, with service accounts available for suitable server-to-server or Workspace configurations. Martini can consume these APIs in workflows, expose callback endpoints for Drive notifications, transform enterprise data into presentation content, and coordinate scheduled or request-driven presentation generation.
| Integration point | Supported by Google Slides? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | The Google Slides API retrieves presentations, reads slides and page elements, and creates or updates presentation content through REST over HTTPS with JSON bodies. | Martini can consume the Google Slides REST API, map request and response data, expose reusable APIs, and orchestrate multi-step presentation workflows. |
| Google Drive REST APIs | Yes | Drive APIs support presentation file metadata, search, copying, permissions, downloads, exports, and supported change monitoring alongside Slides operations. | Martini can call Drive endpoints within the same workflow to locate templates, copy files, manage references, export results, and reconcile changes. |
| Webhooks / outbound callbacks | Limited | Google Drive supports push notification channels for selected watched resources. Notifications indicate that a resource may have changed and are not complete field-level Slides events. | Martini can expose a REST callback endpoint, validate and correlate notifications, then retrieve the current Drive or Slides state for idempotent reconciliation. |
| Batch mutation requests | Yes | The Slides batchUpdate operation groups multiple presentation mutations, such as creating slides, inserting text, and applying formatting, into one request. | Martini workflows can construct ordered batchUpdate requests, map generated object IDs, and handle rejected batches through validation and error paths. |
| File export and download | Yes | Google Drive supports downloading and exporting Google Workspace files to supported formats, subject to permissions, quotas, file-size constraints, and conversion behavior. | Martini can trigger exports, transfer resulting files to downstream systems, and apply format, size, and permission validation before distribution. |
| Authentication | Yes | OAuth 2.0 with Google API scopes is the standard approach; service accounts can support suitable server-to-server or Workspace domain-delegated access. | Martini can store OAuth credentials, refresh tokens, client secrets, and service-account credentials in secured environment configuration or secrets management. |
| SDKs | Yes | Google provides client libraries for several programming languages, although the integration can use the REST API directly without an SDK. | Martini can consume the HTTP APIs directly and reserve custom JVM-compatible logic for request construction or response processing that requires additional flexibility. |
How Google Slides exposes data and business events
Google Slides REST APIs
The Google Slides API is a REST service with JSON request and response bodies. It supports retrieving presentations, reading slide content, creating slides, manipulating page elements, replacing text, applying formatting, and submitting presentation mutations.
Martini implementation pattern
Martini uses a workflow to authenticate to Google APIs, retrieve the target presentation or template, transform source data into Slides API request structures, and submit ordered REST calls or batchUpdate requests. The workflow validates responses and stores presentation identifiers for later reconciliation.
Implementation sequence
Google Drive change notifications
Google Drive supports push notification channels for selected watched resources. A notification indicates that a watched resource may have changed; it is not a complete event payload describing every slide, text, or formatting change.
Martini implementation pattern
Martini exposes a REST API endpoint for the callback, validates the channel and request context, and starts a reconciliation workflow. The workflow retrieves the relevant Drive or Slides resource, compares current state with application-managed synchronization data, and processes the result idempotently.
Implementation sequence
Slides batchUpdate mutations
Google Slides batchUpdate groups multiple presentation mutations into a single request. It can support related operations such as creating a slide, inserting text, and applying formatting, but it is not a general asynchronous bulk-processing service.
Martini implementation pattern
Martini builds an ordered mutation list from canonical presentation data and template metadata. The workflow accounts for dependencies between requests, validates object IDs and supported operations, submits the batch, and routes rejected requests to error handling and retry logic.
Implementation sequence
Google Drive file operations
Google Drive APIs complement Slides by providing file metadata, search, copying, permissions, downloads, exports, and supported upload or conversion operations.
Martini implementation pattern
Martini combines Drive and Slides calls in an orchestrated workflow. It can locate or copy a template, invoke Slides mutations, apply file-level access rules, export the result, and deliver the file to another enterprise endpoint while preserving the source and output references.
Implementation sequence
Common Google Slides integration patterns
Pattern 1: Generate executive presentations from business data
When to use this pattern
Use this pattern when CRM, ERP, reporting, or warehouse data must be turned into a repeatable executive presentation. A scheduled workflow can generate a presentation from a controlled template and apply business rules for reporting periods, missing values, and audience-specific content.
Integration direction
Example Mapping
| Google Slides Field | Canonical Field | Target Field |
|---|---|---|
| Account.Name | customerName | Shape.text |
| Opportunity.Amount | pipelineValue | Table.cell.value |
| Opportunity.StageName | pipelineStage | Shape.text |
| Report.PeriodEnd | reportingPeriod | Shape.text |
Martini implementation pattern
Martini retrieves source data, normalizes it into a canonical reporting model, validates required measures, and copies a Google Slides template through Drive. It then creates ordered batchUpdate mutations for placeholders, shapes, and tables, records the generated presentation ID, and routes quota, permission, or mutation failures through retryable error handling.
Martini capabilities used
- workflows
- API consumption
- scheduling
- data mapping
- business rules
- batch orchestration
- error handling
Pattern 2: Create customer-specific presentation packs
When to use this pattern
Use this pattern when an API request must generate a presentation for a specific customer, opportunity, or reporting request. The workflow should prevent duplicate outputs and apply Drive permissions appropriate to the requesting user or business process.
Integration direction
Example Mapping
| Google Slides Field | Canonical Field | Target Field |
|---|---|---|
| Customer.id | customerId | Drive file metadata |
| Customer.name | customerName | Shape.text |
| Opportunity.products | productSummary | Table.cell.value |
| Request.requestedBy | requestor | Drive permission principal |
Martini implementation pattern
A Martini API receives the request, authenticates and authorizes it, retrieves source data, checks for an existing output using a source-object key, and copies a template only when needed. The workflow populates the presentation, verifies access requirements, and returns the Drive file ID or a controlled error response.
Martini capabilities used
- APIs
- workflows
- authentication
- data mapping
- business rules
- idempotency controls
- error handling
Pattern 3: Reconcile presentation changes with enterprise systems
When to use this pattern
Use this pattern when downstream systems need awareness of changes to selected presentations. Because Drive notifications do not provide complete field-level Slides events, this pattern combines callbacks with retrieval and reconciliation rather than treating each notification as a precise change record.
Integration direction
Example Mapping
| Google Slides Field | Canonical Field | Target Field |
|---|---|---|
| Drive.fileId | presentationId | External documentReference |
| Drive.modifiedTime | sourceModifiedAt | synchronizationTimestamp |
| Slide.pageElements.text | approvedContent | External summary |
| Drive.changeToken | reconciliationCursor | Synchronization state |
Martini implementation pattern
Martini receives the Drive callback, validates the notification channel, retrieves the current presentation or relevant Drive changes, compares it with stored synchronization state, and updates the downstream system only when applicable. Processing keys and current-state reads make retries safe when duplicate or delayed notifications occur.
Martini capabilities used
- REST APIs
- API exposure
- webhook consumption
- workflows
- state management
- data mapping
- error handling
Pattern 4: Export presentations for downstream distribution
When to use this pattern
Use this pattern when completed Google Slides presentations must be delivered as supported files to document management, storage, email, or content-delivery applications. Export format, conversion fidelity, permissions, and file size should be validated before production use.
Integration direction
Example Mapping
| Google Slides Field | Canonical Field | Target Field |
|---|---|---|
| Presentation.presentationId | sourceFileId | document.externalId |
| Drive.exportMimeType | requestedFormat | document.contentType |
| ExportedFile.bytes | documentContent | document.binaryContent |
| Presentation.title | documentName | document.name |
Martini implementation pattern
A scheduled or API-triggered Martini workflow locates the presentation, calls the appropriate Drive export or download operation, validates the returned format and size, and transfers the file to the target system. It records the source ID, output metadata, and failure details for repeatable retries.
Martini capabilities used
- workflows
- API consumption
- scheduling
- file handling
- validation
- data mapping
- error handling
Applications commonly integrated with Google Slides
Google Slides can be integrated with named enterprise applications to generate reporting decks, customer presentations, operational summaries, and team notifications. These are standards-based integration patterns using each application’s APIs and Google Slides or Drive APIs rather than confirmed prebuilt Martini connectors.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Generate account reviews, opportunity presentations, and executive updates from CRM data, while optionally returning the generated Drive file ID or URL to Salesforce. | Salesforce → Martini → Google Slides | Martini retrieves Salesforce data, applies presentation-specific mappings and business rules, copies a Google Slides template through Drive, submits Slides batchUpdate mutations, and returns the presentation reference or status. |
| HubSpot | Produce sales, marketing, and campaign performance presentations from HubSpot data. | HubSpot → Martini → Google Slides | A Martini workflow consumes HubSpot APIs, normalizes campaign and performance values, replaces template placeholders, updates supported page elements, and records the resulting Google Drive file ID. |
| ServiceNow | Create incident, service-review, and operational-summary presentations from ServiceNow data. | ServiceNow → Martini → Google Slides | Martini retrieves selected ServiceNow data, validates reporting criteria, maps it to slide sections, updates a copied presentation, and handles API or mutation failures with workflow error paths. |
| Jira | Turn sprint, release, issue, and delivery metrics into project presentations. | Jira → Martini → Google Slides | Martini calls Jira APIs on a schedule or request, transforms issue and sprint metrics into canonical reporting data, applies conditional slide content, and uses batchUpdate to reduce presentation API round trips. |
| NetSuite | Generate finance, customer, and operational reporting decks from ERP data. | NetSuite → Martini → Google Slides | A Martini workflow retrieves authorized NetSuite data, applies period and aggregation rules, populates text and table content in a Slides template, and exports the result through Drive when a downstream file is required. |
| Workday | Create workforce planning, headcount, and HR reporting presentations subject to Workday permissions and data policies. | Workday → Martini → Google Slides | Martini consumes approved Workday API data, filters sensitive fields, maps workforce metrics to presentation placeholders, and creates a controlled output presentation with Drive permissions considered separately. |
| Zendesk | Build support-volume, SLA, and customer-service review presentations. | Zendesk → Martini → Google Slides | Martini retrieves Zendesk metrics, validates reporting windows, transforms them into slide-ready values, updates a presentation through batchUpdate, and logs rejected or incomplete source data for review. |
| Slack | Notify teams when generated presentations are ready and distribute links to approved Google Drive files. | Google Slides → Martini → Slack | After creating or exporting a presentation, Martini verifies the Drive file reference and permissions, formats a notification payload, and sends it to Slack through its available API or webhook mechanism. |
How to build a Google Slides integration in Martini
Objective
Establish authorized access to Google Slides and, when required, Google Drive using least-privilege OAuth scopes or an approved service-account configuration.
Instructions in Martini
- Configure Google API OAuth credentials or service-account access in secured Martini environment configuration.
- Request only the Slides and Drive scopes required by the workflow.
- Confirm that the authenticated principal has access to the target presentations and Drive files.
Objective
Select the execution model that matches the business requirement: API request, scheduled synchronization, or a Drive notification callback.
Instructions in Martini
- Use an exposed Martini REST API for on-demand presentation generation.
- Use a scheduler for reconciliation, reporting, or export workflows.
- Use a secured callback endpoint only for supported Drive notification channels.
Objective
Collect source business data and the required Google Slides or Drive resource before applying mutations or synchronization logic.
Instructions in Martini
- Retrieve the source application data and validate required fields.
- Locate or copy the target presentation template through Drive when applicable.
- Read the current presentation state before retryable updates.
Objective
Coordinate authentication, source calls, template operations, Slides mutations, Drive operations, and downstream delivery in a maintainable Martini workflow.
Instructions in Martini
- Separate source retrieval, transformation, presentation mutation, and delivery stages.
- Use reusable workflow logic for common template and export operations.
- Persist presentation IDs and processing keys for later reconciliation.
Objective
Convert enterprise data into the Google Slides object and request structures required by the template and the Slides API.
Instructions in Martini
- Map source fields to text, shapes, tables, images, or other supported page elements.
- Normalize dates, amounts, labels, and reporting periods before constructing requests.
- Validate object IDs, content limits, and required values before batchUpdate.
Objective
Enforce business rules for audience, reporting periods, duplicate prevention, permissions, and incomplete or sensitive source data.
Instructions in Martini
- Check whether an output presentation already exists for the source business object.
- Suppress or transform fields that should not appear in the presentation.
- Verify that requested recipients and Drive permissions meet policy requirements.
Common Google Slides data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Presentations | Represent Google Slides files, including metadata, page size, theme information, and ordered slides. | CRM, ERP, reporting platforms, document management, and data warehouses | Martini retrieves or creates presentations, stores the Google Drive file ID, applies template and idempotency rules, and coordinates subsequent slide mutations. |
| Slides | Represent individual presentation pages and their layout and page-element content. | Reporting applications, project systems, customer portals, and content distribution platforms | Martini maps source business sections to slide IDs or stable template markers and uses batchUpdate operations to create, reorder, duplicate, or modify slides. |
| Page elements | Represent objects placed on slides, including text boxes, images, tables, lines, videos, and groups. | Reporting systems, document repositories, collaboration tools, and downstream file workflows | Martini transforms source values into supported element mutations, validates object references, and groups related changes into ordered requests. |
| Shapes | Provide drawable elements such as rectangles, text boxes, and predefined shapes that can contain text. | CRM, finance reporting, operations reporting, and presentation-generation workflows | Martini replaces text, applies supported formatting and transformations, and handles missing or changed template object IDs as workflow errors. |
| Tables | Represent structured rows, columns, and cells within a presentation. | ERP, CRM, analytics applications, and executive reporting platforms | Martini converts source datasets into table-oriented mutations, applies validation and size rules, and submits related updates through batchUpdate. |
| Speaker notes | Store notes associated with a presentation or slide, including speaker-notes page elements. | Learning platforms, sales enablement systems, document repositories, and presentation review workflows | Martini reads or updates supported notes-related content when required, preserving the distinction between visible slide content and speaker notes. |
Authentication and security considerations
OAuth and service accounts
Google Slides access normally uses OAuth 2.0 with Google API scopes. Service accounts can support server-to-server access when files are shared with the account or Workspace domain-wide delegation is configured.
Least-privilege access
Use only the Slides and Drive scopes required for the workflow. Drive permissions, shared-drive policies, ownership rules, and Workspace administration continue to govern access after authentication.
Martini secrets
Store OAuth refresh tokens, client secrets, and service-account credentials in secured Martini environment configuration or secrets management. Do not place credentials in workflow payloads or source code.
Operational considerations for Google Slides integrations
Quotas and retries
Google APIs apply per-project and per-user quotas. Handle HTTP 429 and related responses with appropriate backoff, avoid unnecessary per-element calls, and prefer batchUpdate for related mutations.
Pagination and state
Drive list and change operations can be paginated. Continue with returned page tokens and store presentation IDs, modification timestamps, change cursors, or application-managed processing keys.
Idempotency and templates
Retries can create duplicate content or presentations. Check for existing outputs, use deterministic naming, and maintain source-to-file relationships. Template changes can also invalidate slide, shape, placeholder, or object-ID assumptions.
Notifications and exports
Drive notification channels require lifecycle management, including correlation, renewal, expiration, and cleanup. Export formats, conversion fidelity, embedded media, permissions, and file-size constraints should be tested with representative presentations.
Testing and schema changes
Test presentations containing the required shapes, tables, images, videos, notes, and realistic content volumes. Validate batch request ordering and monitor both Slides and Drive API behavior as supported operations evolve.
Why use Martini instead of scripts or point-to-point integrations?
Orchestrate more than API calls
Martini coordinates source-system retrieval, Google Slides mutations, Google Drive file operations, authorization, transformation, downstream delivery, and reconciliation in a single workflow model.
Reusable integration logic
Template handling, presentation generation, export, validation, and error paths can be implemented as reusable integration assets rather than repeated point-to-point scripts.
Reliable operations
Martini provides workflow-level business rules, idempotency design, retry handling, logging, and monitoring patterns for quota responses, permissions, failed mutations, and callback-driven synchronization.
Controlled APIs
Martini can expose an API façade for presentation-generation requests or callback receipt, allowing enterprise applications to use a stable interface while Google API details remain behind the workflow.
Frequently asked questions
Google Slides can be integrated through its REST API for retrieving presentations and modifying slides, shapes, tables, text, images, and other supported page elements. Google Drive APIs complement this with file search, copying, permissions, export, download, and selected change notifications. OAuth 2.0 or suitable service-account configurations provide authorization.
Yes. Martini can consume the Google Slides REST API and Google Drive APIs, orchestrate presentation-generation workflows, map enterprise data into Slides mutations, expose REST endpoints, and receive supported Google Drive callback notifications.
No. A dedicated Google Slides connector is not required. Martini can integrate using Google Slides and Google Drive REST APIs, OAuth authentication, supported Drive notification callbacks, and file operations confirmed for the required use case.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Google Slides. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Google, cloud infrastructure, or other third-party systems based on subscriptions, usage, quotas, and deployment choices.
Use the Google Slides API for presentation content and slide mutations. Use the Google Drive API for file metadata, searching, copying, permissions, downloads, exports, and supported change notifications. The supplied research does not confirm an official Google Slides GraphQL or SOAP API.
Google Slides does not provide a confirmed general-purpose webhook for every presentation edit. Google Drive supports push notification channels for selected watched resources, but notifications indicate that a resource may have changed and normally require a follow-up retrieval and reconciliation workflow.
Synchronization can be request-driven or scheduled, or it can combine Drive notifications with periodic reconciliation. Martini stores presentation and Drive file identifiers, retrieves current state, maps content to a canonical model, and uses idempotency controls so duplicate or delayed notifications do not create duplicate outputs.
Martini can transform source data into Slides API request structures, validate template object identifiers, group related mutations in batchUpdate, and apply business rules before writing. Workflows can handle quota and transient failures with retry paths, while stored source-to-presentation relationships and processing keys help prevent duplicate presentations.
Related Martini documentation
APIs
Workflows
Integrate Google Slides with Martini
Use Martini to connect Google Slides with enterprise applications, automate presentation generation, reconcile Drive changes, and deliver controlled, maintainable workflows.