Go SDK

Go SDK (planned)

A Go client for the pptx.dev REST API is planned. It is not available as a Go module, so there is nothing to install today. The examples below show the intended API shape; call the REST API directly in the meantime.

← REST API reference Source on GitHub →OPF reference →TypeScript SDK →

Availability

Not available yet

No importable Go module is published, so there is no go get command. Until it ships, call the REST API directly with net/http.

First call

Create a client with your Clerk API key and validate an OPF document. Validation is always free.

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "os"

    pptxdev "pptx.dev/go"
)

func main() {
    client, err := pptxdev.NewClient(os.Getenv("PPTX_API_KEY"))
    if err != nil {
        log.Fatal(err)
    }

    opf := json.RawMessage(`{
        "$schema": "https://openpresentation.org/schema/opf/v1",
        "name": "Hello",
        "slides": [{ "title": "Hello, world" }]
      }`)

    result, err := client.Validate(context.Background(), opf)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(result.Valid, result.Errors, result.Warnings)
}

Authentication

Pass a bearer token to NewClient. An empty string sends unauthenticated requests (only the /v1/preview anonymous endpoint supports that).

client, err := pptxdev.NewClient("ak_...")
// or read from env:
client, err := pptxdev.NewClient(os.Getenv("PPTX_API_KEY"))

Get your Clerk API key from the API Keys page.

Generate a .pptx from OPF

doc := json.RawMessage(`{
    "$schema": "https://openpresentation.org/schema/opf/v1",
    "name": "Q1 Review",
    "filename": "q1-review",
    "slides": [{ "title": "Q1 Review" }]
  }`)

result, err := client.GeneratePPTX(context.Background(), doc)
if err != nil {
    log.Fatal(err)
}
filename := result.Filename
if filename == "" {
    filename = "q1-review.pptx"
}
if err := os.WriteFile(filename, result.Content, 0644); err != nil {
    log.Fatal(err)
}
fmt.Println(filename, result.SlideCount)

Parse an existing .pptx

f, err := os.Open("deck.pptx")
if err != nil {
    log.Fatal(err)
}
defer f.Close()

accepted, err := client.ParsePPTX(context.Background(), "deck.pptx", f)
if err != nil {
    log.Fatal(err)
}

slide0, err := client.ParseSlide(context.Background(), accepted.ParseID, 0)
if err != nil {
    log.Fatal(err)
}
fmt.Println(slide0.TextRuns)

Error handling

Non-2xx responses return structured errors you can type-assert with errors.As.

Error	When
*APIError	HTTP 4xx / 5xx. Exposes `StatusCode` and raw `Body`.
*OpfValidationError	HTTP 422 from `GeneratePPTX` with `ValidationErrors[]`

import "errors"

_, err := client.GeneratePPTX(ctx, badDoc)
if err != nil {
    var vErr *pptxdev.OpfValidationError
    var apiErr *pptxdev.APIError
    switch {
    case errors.As(err, &vErr):
        log.Printf("OPF schema errors: %+v", vErr.ValidationErrors)
    case errors.As(err, &apiErr):
        log.Printf("API %d: %s", apiErr.StatusCode, string(apiErr.Body))
    default:
        log.Fatal(err)
    }
}

Render (web, png, svg)

f, _ := os.Open("deck.pptx")
defer f.Close()

// Synchronous web render
web, err := client.RenderWeb(ctx, "deck.pptx", f, nil)
if err != nil {
    log.Fatal(err)
}
fmt.Println(web.Slides)

// Async PNG / SVG export
f2, _ := os.Open("deck.pptx")
defer f2.Close()
job, err := client.RenderExport(ctx, "deck.pptx", f2, "png", []int{1, 2})
if err != nil {
    log.Fatal(err)
}
fmt.Println(job.Status, job.ViewerURL)

Custom base URL

For local development against a Next.js dev server, or to target a staging host:

client, err := pptxdev.NewClient(
    "ak_...",
    pptxdev.WithBaseURL("http://localhost:3000/api"),
    pptxdev.WithHTTPClient(&http.Client{Timeout: 30 * time.Second}),
)