Midaz SDK for Go

The Midaz SDK for Go is the Go client for the Midaz ledger and Tracer APIs. It gives you typed access to each service (Organizations, Ledgers, Accounts, Transactions, and more) with one surface for authentication, pagination, errors, retries, logging, and observability.

Getting started

Step 1 – Install Go

Install Go before you use the SDK. The SDK declares Go 1.26 in go.mod. Its public API uses iter.Seq2 and log/slog.

Go to the official Go website.

Download the installer for your OS (Windows, macOS, or Linux).

Follow the installation instructions.

Step 2 – Create or use an existing Go project

Create a Go project: To create a Go project, use the following command:

mkdir my-midaz-app
cd my-midaz-app
go mod init my-midaz-app

Use an existing Go project: If you’re working in an existing project, make sure there’s a go.mod file in the root. If not, run the following command to create one:

go mod init your-module-name

Step 3 – Add the Midaz SDK

Inside your project directory, run the following command to add the SDK to your go.mod and go.sum files:

The module path requires the /v6 suffix. If you omit it, Go resolves an old v1 release. Import github.com/LerianStudio/midaz-sdk-golang/v6.

go get github.com/LerianStudio/midaz-sdk-golang/v6

In VS Code or GoLand, your IDE may automatically run go get when you import a new package.

Step 4 – Import the SDK

Create or open a main.go file and add the following content. The example builds a client against your local Midaz stack with anonymous authentication, lists organizations, then creates a new one.

The example below targets a local Midaz stack with auth disabled. If you don’t have one running yet, see Getting started with Midaz to spin one up before running the snippet.

package main

import (
	"context"
	"fmt"
	"log"

	midaz "github.com/LerianStudio/midaz-sdk-golang/v6"
	"github.com/LerianStudio/midaz-sdk-golang/v6/models"
)

func main() {
	// Build a client. The SDK requires exactly one auth source: use
	// midaz.WithAnonymous() for a local stack, or midaz.WithAccessManager(...)
	// for a development or production environment.
	c, err := midaz.New(
		midaz.WithEnvironment(midaz.EnvironmentLocal),
		midaz.WithAnonymous(),
	)
	if err != nil {
		log.Fatalf("midaz.New: %v", err)
	}
	defer c.Shutdown(context.Background())

	ctx := context.Background()

	// List the first 5 organizations using a typed list-opts struct.
	page, err := c.V2.Organizations.List(ctx, models.OrganizationsListOpts{
		PageListOpts: models.PageListOpts{Limit: 5},
	})
	if err != nil {
		log.Fatalf("list organizations: %v", err)
	}

	for _, org := range page.Items {
		fmt.Printf("- %s (%s)\n", org.LegalName, org.ID)
	}

	// Create a new organization. midaz.CreateOrganizationInput is the same
	// type as models.CreateOrganizationInput, re-exported on the midaz package.
	dba := "Example Inc."
	org, err := c.V2.Organizations.Create(ctx, &midaz.CreateOrganizationInput{
		LegalName:       "Example Corporation",
		LegalDocument:   "123456789",
		DoingBusinessAs: &dba, // optional fields are *string
		Address: midaz.Address{
			Line1:   "123 Main St",
			City:    "New York",
			State:   "NY",
			ZipCode: "10001",
			Country: "US",
		},
	})
	if err != nil {
		log.Fatalf("create organization: %v", err)
	}

	fmt.Printf("Organization created: %s\n", org.ID)
}

This gives you access to:

The Midaz client for calling each API service.
Built-in data models (like CreateOrganizationInput).
Auth via Access Manager (production) or Anonymous (local development).
A typed configuration system that fails at construction time.

For the full setup, see the Authentication section.

Step 5 – Run the project

Run the following command:

go run main.go

SDK architecture

Layered design

Layer	What it handles
Client	The main entry point. `midaz.New(...)` wires authentication, retries, and observability.
Services	Access to each Midaz domain, grouped by the API version that serves it.
Models	The data structures of the Midaz domain. The common ones are re-exported on the `midaz` package.
Utility packages	Helpers for config, errors, observability, retries, idempotency, and more.

Services

Midaz serves two ledger API versions: /v1, which is deprecated, and /v2. The SDK groups the ledger services by the version that serves them. Build against c.V2. A resource that one version does not serve is a compile error, not a 404.

orgs, err := c.V2.Organizations.List(ctx, opts)
account, err := c.V2.Accounts.Get(ctx, orgID, ledgerID, accountID)
tx, err := c.V2.Transactions.CreateDirect(ctx, orgID, ledgerID, input)

// /v1 only:
rate, err := c.V1.AssetRates.GetAssetRate(ctx, orgID, ledgerID, externalID)

Group	Services
`c.V2` and `c.V1`	`Organizations`, `Ledgers`, `Accounts`, `AccountTypes`, `Assets`, `Balances`, `Operations`, `Portfolios`, `Segments`, `OperationRoutes`, `TransactionRoutes`, `Transactions`, `MetadataIndexes`
`c.V2` only	`Holders`, `Instruments`, `Encryption`, `Composition`, `ProtectionAudit`, `BillingPackages`, `FeePackages`, `FeeEstimates`, `BillingCalculations`
`c.V1` only	`AssetRates`
Tracer, on the client	`c.Rules`, `c.Limits`, `c.Validations`, `c.Reservations`, `c.AuditEvents`

Transactions has a different contract on each version. On /v1, you create a transaction through one of four creation endpoints with a nested send body. On /v2, c.V2.Transactions creates transactions with a flat body through CreateDirect, CreateHold, CreateBlock, and CreateUnblock. It returns models.TransactionV2.

A 201 response means that Midaz accepted the transaction, not that the balances are settled. To wait for the balance effect, use transaction.WaitForSettlement from the pkg/transaction package.

Models

Each model type represents a business concept. You use them in each service call. The most common model types are re-exported on the midaz package. midaz.Account and models.Account are the same type, so most code needs only one import.

Common model types

Model	What it represents
`midaz.Organization`	A business entity that owns ledgers and accounts.
`midaz.Ledger`	A collection of accounts and transactions.
`midaz.Asset`	A unit of value (currency, token, etc.) that can be stored or moved.
`midaz.Account`	An account for tracking assets and balances.
`midaz.Portfolio`	A collection of accounts for grouping and management.
`midaz.Segment`	A categorization unit for granular organization.
`midaz.Transaction`	A financial event composed of multiple operations.
`midaz.Operation`	An individual debit or credit entry within a transaction.
`midaz.Balance`	The current state of an account’s holdings.

For a type that is not re-exported, such as models.TransactionV2, import github.com/LerianStudio/midaz-sdk-golang/v6/models directly. The midaz aliases keep the type identity, so the two import paths work together.

Utility packages

The pkg folder of the SDK holds utility packages. Core packages serve concerns that apply to the whole SDK. Helper packages give domain-specific or low-level utilities.

Core packages

Package	What it solves
`auth`	Access Manager OAuth and the token lifecycle.
`config`	Config handling, environment loading, and custom service URLs.
`concurrent`	Tools for batching, rate-limiting, and worker pools.
`errors`	Structured error types, classifiers, and the `Retryable()` predicate.
`observability`	Tracing, metrics, and logs through one OpenTelemetry provider.
`retry`	Retry policy options with exponential backoff and jitter.
`sdkctx`	Per-request context flags, such as idempotency keys.
`validation`	Input validation with structured error messages.

Helper packages

Package	What it solves
`accounts`	Account-specific helpers and convenience functions.
`conversion`	Type conversion helpers between models and external formats.
`data`	Data utilities and faker helpers for testing and demos.
`format`	Utilities for formatting data the Midaz way (dates, times, etc.).
`generator`	Demo and mass-data generation for end-to-end scenarios.
`integrity`	Checksum and integrity verification utilities.
`performance`	Helpers for tuning bulk operations and high-throughput tasks.
`security`	Security utilities, including SSRF protection and TLS validation.
`stats`	Processing statistics and metrics aggregation.
`transaction`	Transaction helpers, such as the settlement wait.
`utils`	General-purpose helpers used across the SDK.
`version`	SDK version metadata and identification.

Authentication

The SDK requires exactly one authentication source at construction time. If you call midaz.New(...) with neither, it returns a typed configuration error. You have two choices:

midaz.WithAccessManager(...): OAuth through the Lerian Access Manager. Use it for any non-local stack.
midaz.WithAnonymous(): no authentication. Use it only for a local Midaz stack with auth disabled.

If you apply both options, the last one wins.

Production: Access Manager

Put your Access Manager credentials in midaz.WithAccessManager. The SDK requests a token from your Access Manager, attaches it to each API call, and refreshes it when it expires.

Replace the values in the // Configure Access Manager block with your own credentials before running.

package main

import (
	"context"
	"log"
	"os"

	midaz "github.com/LerianStudio/midaz-sdk-golang/v6"
)

func main() {
	// Configure Access Manager. Load ClientID and ClientSecret from
	// environment variables; do not hardcode them.
	c, err := midaz.New(
		midaz.WithEnvironment(midaz.EnvironmentProduction),
		midaz.WithAccessManager(midaz.AccessManager{
			Address:      "https://auth.example.com",
			ClientID:     os.Getenv("MIDAZ_CLIENT_ID"),
			ClientSecret: os.Getenv("MIDAZ_CLIENT_SECRET"),
		}),
	)
	if err != nil {
		log.Fatalf("midaz.New: %v", err)
	}
	defer c.Shutdown(context.Background())

	// Use c.V2.Organizations, c.V2.Ledgers, c.V2.Accounts, ...
}

Local development: Anonymous

For a local Midaz stack with auth disabled, opt out explicitly:

c, err := midaz.New(
    midaz.WithEnvironment(midaz.EnvironmentLocal),
    midaz.WithAnonymous(),
)

Configure via environment variables

You can also point the SDK at your Access Manager with environment variables. Export them in your shell or your process manager:

export PLUGIN_AUTH_ENABLED=true
export PLUGIN_AUTH_ADDRESS=https://your-auth-service.com
export MIDAZ_CLIENT_ID=your-client-id
export MIDAZ_CLIENT_SECRET=your-client-secret

config.FromEnvironment() reads the process environment, not a .env file. If you keep variables in a .env file during development, load them with a library like godotenv before calling config.NewConfig(config.FromEnvironment()).

Then opt in to environment loading at config time:

import "github.com/LerianStudio/midaz-sdk-golang/v6/pkg/config"

cfg, err := config.NewConfig(config.FromEnvironment())
if err != nil {
    log.Fatalf("config: %v", err)
}

c, err := midaz.New(midaz.WithConfig(cfg))

Environment loading is explicit. Put config.FromEnvironment() in the option chain. The SDK does not read environment variables during construction without it.

For the full auth walkthrough, see the Authentication guide in the SDK repo.

Tenant scope

Tenant scope comes from the Access Manager / JWT claims used to obtain the token. The SDK has no tenant configuration and does not send a tenant header. To run calls under a different tenant scope, use a separate set of Access Manager credentials, or build a second client with its own token context.

Listing and iteration

Most list endpoints come in three methods. Pick the one that matches your use case.

Method	Returns	Use when
`List`	`*models.ListResponse[T]` (one page)	You want exactly one page and decide when to advance.
`All`	`iter.Seq2[T, error]`	You want each item. The SDK handles paging internally.
`Pages`	`iter.Seq2[*models.ListResponse[T], error]`	You need page-level metadata for checkpointing or batching.

Typed list options

Each list method takes a typed opts struct. The struct embeds one of two base structs, based on how the endpoint paginates:

Pagination shape	Endpoints	Base struct
Page-based	Organizations, Ledgers, Assets, Portfolios, Segments, Accounts, AccountTypes, FeePackages, BillingPackages	`models.PageListOpts{Limit, Page, SortDirection, StartDate, EndDate}`
Cursor-based	Transactions, Balances, Holders, Operations, OperationRoutes, TransactionRoutes, AssetRates	`models.CursorListOpts{Limit, Cursor, SortDirection, StartDate, EndDate}`

Some endpoints also expose a typed Filters sub-struct. If you set a field of the wrong shape (for example, Page on a cursor endpoint), the code does not compile.

The transaction list does not filter by Status, AssetCode, Reference, SourceAccount, DestinationAccount, or Route. If you set one of these filters on List, the SDK refuses the call with an error. Count accepts Status and Route.

Iterate every item with `All`

The simplest shape is a range loop over each item across each page. The SDK fetches the pages internally.

opts := models.AccountsListOpts{
    PageListOpts: models.PageListOpts{Limit: 100},
    Filters: models.AccountsFilters{
        Status:    "ACTIVE",
        AssetCode: "USD",
    },
}

for account, err := range c.V2.Accounts.All(ctx, orgID, ledgerID, opts) {
    if err != nil {
        return fmt.Errorf("list accounts: %w", err)
    }
    process(account)
}

Iterate page envelopes with `Pages`

When you need page-level metadata (for checkpointing, batching, or stopping mid-page), iterate over Pages. Each entry is a *models.ListResponse[T] with its Pagination block.

opts := models.TransactionsListOpts{
    CursorListOpts: models.CursorListOpts{Limit: 50},
}

for page, err := range c.V2.Transactions.Pages(ctx, orgID, ledgerID, opts) {
    if err != nil {
        return fmt.Errorf("page iter: %w", err)
    }
    log.Printf("items=%d next_cursor=%q", len(page.Items), page.Pagination.NextCursor)

    for _, tx := range page.Items {
        process(tx)
    }

    if shouldStop(page) {
        break // The SDK stops paging.
    }
}

See the Pagination guide in the SDK repo for NextCursor handling and the page-vs-cursor decision table.

Error handling

The SDK service layer returns errors as *pkg/errors.Error with structured fields:

Field	What it carries
`Category`	The error class (validation, authentication, network, configuration, and so on).
`Code`	A stable string code for branching or telemetry.
`Operation`	The SDK operation that produced the error.
`Resource`	The resource family the error refers to, when relevant.

You can branch with typed predicates, read fields with errors.As, or use the Retryable() method to drive retry policy.

Branch with typed predicates

The SDK has a set of Is* predicates, so you can match errors without reading internals:

import (
    "errors"
    "fmt"

    sdkerrors "github.com/LerianStudio/midaz-sdk-golang/v6/pkg/errors"
)

acc, err := c.V2.Accounts.Get(ctx, orgID, ledgerID, accountID)
if err != nil {
    switch {
    case sdkerrors.IsNotFoundError(err):
        return fmt.Errorf("account not found: %w", err)
    case sdkerrors.IsAuthError(err):
        return fmt.Errorf("auth failure: %w", err)
    case sdkerrors.IsValidationError(err):
        return fmt.Errorf("invalid input: %w", err)
    case sdkerrors.IsConflictError(err):
        return fmt.Errorf("already exists: %w", err)
    case sdkerrors.IsRateLimitError(err):
        return fmt.Errorf("rate limited: %w", err)
    case sdkerrors.IsNetworkError(err):
        return fmt.Errorf("transient transport: %w", err)
    case sdkerrors.IsConfigurationError(err):
        return fmt.Errorf("setup mistake: %w", err)
    }

    // Read the structured fields when you need them.
    var sdkErr *sdkerrors.Error
    if errors.As(err, &sdkErr) {
        log.Printf("op=%s resource=%s code=%s retryable=%v",
            sdkErr.Operation, sdkErr.Resource, sdkErr.Code, sdkErr.Retryable())
    }
}

Drive retry decisions with `Retryable()`

The Error.Retryable() method derives from Category. Use it instead of your own classification.

var sdkErr *sdkerrors.Error
if errors.As(err, &sdkErr) && sdkErr.Retryable() {
    // Apply your retry logic: backoff, jitter, max attempts, etc.
}

Wrap raw transport errors

If you call lower-level HTTP code outside the SDK and want the same structured error shape, use ClassifyTransportError:

import sdkerrors "github.com/LerianStudio/midaz-sdk-golang/v6/pkg/errors"

resp, err := httpClient.Do(req)
if err != nil {
    return sdkerrors.ClassifyTransportError("PaymentService.Charge", err)
}

Local validation: FieldErrors

Local input validation returns *pkg/validation.FieldErrors, a collection of per-field errors that the SDK finds before any HTTP call. Use errors.As to read them.

import (
    "errors"
    "fmt"

    "github.com/LerianStudio/midaz-sdk-golang/v6/pkg/validation"
)

var fieldErrs *validation.FieldErrors
if errors.As(err, &fieldErrs) {
    for _, fe := range fieldErrs.Errs() {
        fmt.Printf("- %s: %s\n", fe.Field, fe.Message)
    }
}

For the full category map, each code, and retry boundaries, see the Error handling guide in the SDK repo.

Retries

The default policy retries 3 times with exponential backoff and 25% jitter. It retries transport errors and the statuses 408, 425, 429, 500, 502, 503, and 504. The SDK retries POST, PUT, PATCH, and DELETE only when the request has an X-Idempotency header.

import (
    "time"

    "github.com/LerianStudio/midaz-sdk-golang/v6/pkg/retry"
)

c, err := midaz.New(
    midaz.WithEnvironment(midaz.EnvironmentLocal),
    midaz.WithAnonymous(),
    midaz.WithRetryOptions(
        retry.WithMaxRetries(5),
        retry.WithInitialDelay(200*time.Millisecond),
    ),
)

Use midaz.WithCustomRetryPolicy for your own retry predicate. To turn retries off, use midaz.WithoutRetries().

Logging

*slog.Logger is the logger surface of the SDK. Wire it with midaz.WithLogger(...). The SDK is silent by default: it uses slog.DiscardHandler until you opt in. You decide the handler, the level, and the destination.

package main

import (
    "context"
    "log"
    "log/slog"
    "os"

    midaz "github.com/LerianStudio/midaz-sdk-golang/v6"
)

func main() {
    logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
        Level: slog.LevelInfo,
    }))

    c, err := midaz.New(
        midaz.WithEnvironment(midaz.EnvironmentLocal),
        midaz.WithAnonymous(),
        midaz.WithLogger(logger),
    )
    if err != nil {
        log.Fatalf("midaz.New: %v", err)
    }
    defer c.Shutdown(context.Background())

    // SDK log lines now go to your handler.
}

charmbracelet/log, zap, and zerolog integrate through slog.Handler.

The Logging guide has adapter recipes for common logging libraries.

Observability

One observability provider gives you spans, metrics, and OpenTelemetry-correlated logs through one wiring point. Pass a provider that you build, or pass options that the SDK assembles for you.

Wire a provider

package main

import (
    "context"
    "log"

    midaz "github.com/LerianStudio/midaz-sdk-golang/v6"
    "github.com/LerianStudio/midaz-sdk-golang/v6/pkg/observability"
)

func main() {
    ctx := context.Background()

    provider, err := observability.New(ctx,
        observability.WithServiceName("payments-api"),
        observability.WithEnvironment("production"),
        observability.WithComponentEnabled(true, true, true), // tracing, metrics, logs
    )
    if err != nil {
        log.Fatalf("observability.New: %v", err)
    }
    defer provider.Shutdown(ctx)

    c, err := midaz.New(
        midaz.WithEnvironment(midaz.EnvironmentProduction),
        midaz.WithAccessManager(midaz.AccessManager{ /* ... */ }),
        midaz.WithObservabilityProvider(provider),
    )
    if err != nil {
        log.Fatalf("midaz.New: %v", err)
    }
    defer c.Shutdown(ctx)
}

Or pass options inline

import "github.com/LerianStudio/midaz-sdk-golang/v6/pkg/observability"

c, err := midaz.New(
    midaz.WithEnvironment(midaz.EnvironmentProduction),
    midaz.WithAccessManager(am),
    midaz.WithObservabilityOptions(
        observability.WithServiceName("payments-api"),
        observability.WithComponentEnabled(true, true, true),
    ),
)

The SDK emits one HTTP span per outbound request with W3C traceparent propagation. Business log records carry safe IDs only: no payloads, names, addresses, or auth headers. You can also wrap a block of business logic in a span with Client.Trace:

err = c.Trace("create-organization", func(ctx context.Context) error {
    _, err := c.V2.Organizations.Create(ctx, input)
    return err
})

WithObservabilityOptions and WithObservabilityProvider replace the installed provider. They do not merge. To start from a baseline, put observability.WithDevelopmentDefaults or observability.WithProductionDefaults first in the option chain.

See the 10-observability-otel example in the SDK repo for span attributes, metric names, and exporter setup.

Idempotency

Auto-idempotency is on by default. The SDK sends an X-Idempotency: <uuid> header on each unsafe HTTP request (POST, PUT, PATCH, DELETE). A retry after a transient failure then does not create a resource twice. You can override the generated key per call when you need a stable key of your own. This is typical for saga steps, outbox rows, or UI submissions.

Set a stable key per request

import "github.com/LerianStudio/midaz-sdk-golang/v6/pkg/sdkctx"

ctx := sdkctx.WithIdempotencyKey(context.Background(), "tx-2026-05-06-001")

tx, err := c.V2.Transactions.CreateDirect(ctx, orgID, ledgerID, input)

Suppress idempotency for one call

For rare administrative calls, suppress the header per request:

ctx := sdkctx.WithoutAutoIdempotency(context.Background())

Without the header, the SDK does not retry that unsafe request.

Disable globally

To turn auto-idempotency off everywhere, turn it off at the client level:

c, err := midaz.New(
    midaz.WithEnvironment(midaz.EnvironmentLocal),
    midaz.WithAnonymous(),
    midaz.WithIdempotency(false),
)

You can also set MIDAZ_IDEMPOTENCY=false when you use config.FromEnvironment().

Environment variables

The SDK reads these variables only when config.FromEnvironment() is in your config option chain.

Variable	Description
`MIDAZ_ENVIRONMENT`	Target environment (`local`, `development`, `production`).
`MIDAZ_BASE_URL`	Base URL for the Midaz services, used when the service-specific URLs are not set. Do not add a `/v1` or `/v2` suffix.
`MIDAZ_LEDGER_URL`	Ledger API URL. It serves the onboarding and transaction endpoints.
`MIDAZ_TRACER_URL`	Tracer API URL.
`MIDAZ_TRACER_API_KEY`	Optional API key for Tracer. When you do not set it, Tracer calls use the ledger bearer token.
`PLUGIN_AUTH_ENABLED`	Enable Access Manager authentication (`true` or `false`).
`PLUGIN_AUTH_ADDRESS`	Address of the Access Manager service.
`MIDAZ_CLIENT_ID`	Client ID for Access Manager authentication.
`MIDAZ_CLIENT_SECRET`	Client secret for Access Manager authentication.
`MIDAZ_TIMEOUT`	HTTP request timeout in seconds.
`MIDAZ_DEBUG`	Enable debug logs (`true` or `false`).
`MIDAZ_MAX_RETRIES`	Maximum retry attempts for failed requests.
`MIDAZ_IDEMPOTENCY`	Enable automatic idempotency keys for unsafe requests (`true` or `false`).
`MIDAZ_ERROR_EXPOSE_BODY`	Include the raw response body in `*pkg/errors.Error`.
`MIDAZ_ACCESS_MANAGER_ALLOW_INSECURE_HTTP`	Allow plain HTTP to the Access Manager. The SDK rejects it when `MIDAZ_ENVIRONMENT=production`.
`MIDAZ_ALLOW_INSECURE_HTTP`	Allow plain HTTP to the ledger and Tracer URLs on non-loopback hosts. The SDK rejects it when `MIDAZ_ENVIRONMENT=production`.

For the full option matrix across midaz, pkg/config, and pkg/sdkctx, see the Configuration guide in the SDK repo.

Example projects

The SDK has a numbered set of focused tutorials (examples 01–10), plus advanced and reference examples. Each numbered example teaches one concept. Browse them in the examples directory on GitHub.

Example	What it demonstrates
`01-hello-world`	Minimal init plus the first API call.
`02-auth`	Access Manager authentication (production setup).
`03-end-to-end`	Creating a transaction on `/v2` with `CreateDirect`.
`04-listing-cursor`	Cursor-based pagination with `iter.Seq2`.
`05-listing-pages`	Page-based pagination with `List`, `All`, and `Pages`.
`06-idempotency`	Auto, explicit, and suppressed idempotency modes.
`07-retries`	Default policy, custom policy, disabled retries.
`08-logging-slog`	`*slog.Logger` integration.
`09-testing-with-mocks`	A narrow interface of your own plus a hand-written mock.
`10-observability-otel`	Full OpenTelemetry surface (tracing + metrics + logs).

The repository also includes reference examples: concurrency, configuration, context, tracing, tracing-server, pkg-validation-demo, mass-demo-generator, and workflow-with-entities.

​Getting started

​Step 1 – Install Go

​Step 2 – Create or use an existing Go project

​Step 3 – Add the Midaz SDK

​Step 4 – Import the SDK

​Step 5 – Run the project

​SDK architecture

​Layered design

​Services

​Models

​Common model types

​Utility packages

​Core packages

​Helper packages

​Authentication

​Production: Access Manager

​Local development: Anonymous

​Configure via environment variables

​Tenant scope

​Listing and iteration

​Typed list options

​Iterate every item with All

​Iterate page envelopes with Pages

​Error handling

​Branch with typed predicates

​Drive retry decisions with Retryable()

​Wrap raw transport errors

​Local validation: FieldErrors

​Retries

​Logging

​Observability

​Wire a provider

​Or pass options inline

​Idempotency

​Set a stable key per request

​Suppress idempotency for one call

​Disable globally

​Environment variables

​Example projects

​Explore the APIs

External API mapping

Internal API mapping

Godoc documentation

Getting started

Step 1 – Install Go

Step 2 – Create or use an existing Go project

Step 3 – Add the Midaz SDK

Step 4 – Import the SDK

Step 5 – Run the project

SDK architecture

Layered design

Services

Models

Common model types

Utility packages

Core packages

Helper packages

Authentication

Production: Access Manager

Local development: Anonymous

Configure via environment variables

Tenant scope

Listing and iteration

Typed list options

Iterate every item with `All`

Iterate page envelopes with `Pages`

Error handling

Branch with typed predicates

Drive retry decisions with `Retryable()`

Wrap raw transport errors

Local validation: FieldErrors

Retries

Logging

Observability

Wire a provider

Or pass options inline

Idempotency

Set a stable key per request

Suppress idempotency for one call

Disable globally

Environment variables

Example projects

Explore the APIs