digitalocean/godo

digitalocean/godo

Description: DigitalOcean Go API client

Language: Go

License: NOASSERTION

Stars: 1536

Forks: 371

Open issues: 36

Created: 2014-09-03T14:07:36Z

Pushed: 2026-06-10T16:19:10Z

Default branch: main

Fork: no

Archived: no

README:

Godo

 

Godo is a Go client library for accessing the DigitalOcean V2 API.

You can view the client API docs here: http://godoc.org/github.com/digitalocean/godo

You can view DigitalOcean API docs here: https://docs.digitalocean.com/reference/api/api-reference/

> 🚀 New in v1.191.0 — AI & Inference support > > godo now ships first-class support for DigitalOcean's > Gradient AI Platform: chat > completions (with streaming), image generation, embeddings, batch inference, > model listing, and more — all from the same Client. Jump to > [AI & Inference](#ai--inference) to get started.

Install

go get github.com/digitalocean/godo@vX.Y.Z

where X.Y.Z is the version you need.

or

go get github.com/digitalocean/godo

for non Go modules usage or latest version.

Usage

import "github.com/digitalocean/godo"

Create a new DigitalOcean client, then use the exposed services to access different parts of the DigitalOcean API.

Authentication

You can manage API tokens at the DigitalOcean Control Panel Applications Page.

package main

import (
"github.com/digitalocean/godo"
)

func main() {
client := godo.NewFromToken("my-digitalocean-api-token")
}

> Credentials for inference APIs > > What matters is the credential you pass to godo.NewFromToken, not which > DigitalOcean API you call: > > | What you're calling | What you need | > | --- | --- | > | Infrastructure APIs (Droplets, Kubernetes, Volumes, …) | A DigitalOcean API token (PAT). | > | Inference APIs (Chat, Models, Embeddings, ImageGenerations, Messages, Responses, BatchInference, …) | A PAT created with full access scope, or a Gradient Model Access Key. | > > If you only have a limited-scope PAT, infrastructure calls will work but > inference calls will fail with 401. Create a new PAT with full access, or use > a Model Access Key instead. > > ``go > // Either credential works with godo.NewFromToken: > client := godo.NewFromToken(os.Getenv("DIGITALOCEAN_TOKEN")) // full-access PAT > client := godo.NewFromToken(os.Getenv("MODEL_ACCESS_KEY")) // Gradient model access key >

If you need to provide a context.Context to your new client, you should use `godo.NewClient` to manually construct a client instead.

AI & Inference

> Talk to models on DigitalOcean's Gradient AI Platform with the same godo.Client.

The Serverless Inference API is available at https://inference.do-ai.run/. Use a DigitalOcean PAT with full access scope or a Gradient Model Access Key — see the [credentials note](#authentication) above.

Chat completion

completion, _, err := client.Chat.Completions.New(ctx, &godo.ChatCompletionNewParams{
Model: "llama3.3-70b-instruct",
Messages: []godo.ChatCompletionMessage{
godo.UserMessage("Write me a haiku"),
},
})

List models

page, _, err := client.Models.List(ctx)
for _, m := range page.Data {
fmt.Println(m.ID)
}

Image generation

image, _, err := client.ImageGenerations.Generate(ctx, &godo.ImageGenerateParams{
Model: "stable-diffusion-3.5-large",
Prompt: "A friendly cartoon shark typing on a laptop at a sunny beach",
N: 1,
})

For streaming, embeddings, messages, responses, async invocations, batch inference, agent inference, and full runnable programs, see [examples/serverless-inference/](examples/serverless-inference/) and [examples/agent-inference/](examples/agent-inference/).

Examples

To create a new Droplet:

dropletName := "super-cool-droplet"

createRequest := &godo.DropletCreateRequest{
Name: dropletName,
Region: "nyc3",
Size: "s-1vcpu-1gb",
Image: godo.DropletCreateImage{
Slug: "ubuntu-20-04-x64",
},
}

ctx := context.TODO()

newDroplet, _, err := client.Droplets.Create(ctx, createRequest)

if err != nil {
fmt.Printf("Something bad happened: %s\n\n", err)
return err
}

Pagination

If a list of items is paginated by the API, you must request pages individually. For example, to fetch all Droplets:

func DropletList(ctx context.Context, client *godo.Client) ([]godo.Droplet, error) {
// create a list to hold our droplets
list := []godo.Droplet{}

// create options. initially, these will be blank
opt := &godo.ListOptions{}
for {
droplets, resp, err := client.Droplets.List(ctx, opt)
if err != nil {
return nil, err
}

// append the current page's droplets to our list
list = append(list, droplets...)

// if we are at the last page, break out the for loop
if resp.Links == nil || resp.Links.IsLastPage() {
break
}

page, err := resp.Links.CurrentPage()
if err != nil {
return nil, err
}

// set the page we want for the next request
opt.Page = page + 1
}

return list, nil
}

Some endpoints offer token based pagination. For example, to fetch all Registry Repositories:

func ListRepositoriesV2(ctx context.Context, client *godo.Client, registryName string) ([]*godo.RepositoryV2, error) {
// create a list to hold our registries
list := []*godo.RepositoryV2{}

// create options. initially, these will be blank
opt := &godo.TokenListOptions{}
for {
repositories, resp, err := client.Registry.ListRepositoriesV2(ctx, registryName, opt)
if err != nil {
return nil, err
}

// append the current page's registries to our list
list = append(list, repositories...)

// if we are at the last page, break out the for loop
if resp.Links == nil || resp.Links.IsLastPage() {
break
}

// grab the next page token
nextPageToken, err := resp.Links.NextPageToken()
if err != nil {…