Go

This is the official Go client for Elasticsearch.

Full documentation is hosted at GitHub and PkgGoDev. This documentation provides only an overview of features.

• Strongly typed typed API with compile-time safety and decoded responses.
• Fluent esdsl builders for queries, aggregations, mappings, and sort options.
• Low-level API for raw JSON control and endpoints not yet covered by the typed API.
• Built-in OpenTelemetry instrumentation for distributed tracing.
• Interceptors for custom middleware (auth rotation, observability, etc.).
• Automatic retries, request compression, and node discovery.
• Helpers for convenience (bulk indexing, JSON encoding, and more).
• Rich set of examples.

The client has a layered architecture where the typed and low-level APIs share the same transport infrastructure:

graph LR
    App["Your Application"]
    TC["TypedClient / Client"]
    INT["Interceptors"]
    TP["Transport"]
    ES["Elasticsearch"]

    App --> TC
    TC --> INT
    INT --> TP
    TP --> ES

The transport layer handles retry logic, request compression, node selection (round-robin), and connection pooling. Interceptors are optional middleware that can modify requests and responses (e.g., for dynamic authentication or custom logging). See the Configuration reference for all available options.

The typed client combined with the esdsl builders is the recommended way to use this library:

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/elastic/go-elasticsearch/v9"
    "github.com/elastic/go-elasticsearch/v9/typedapi/esdsl"
)

func main() {
    es, err := elasticsearch.NewTyped(
        elasticsearch.WithAddresses("http://localhost:9200"),
    )
    if err != nil {
        log.Fatal(err)
    }
    defer es.Close(context.Background())

    res, err := es.Search().
        Index("my-index").
        Query(esdsl.NewMatchQuery("title", "golang")).
        Do(context.Background())
    if err != nil {
        log.Fatal(err)
    }

    for _, hit := range res.Hits.Hits {
        fmt.Println(hit.Source_)
    }
}
		

If you need raw JSON control or an endpoint the typed API does not yet cover, see the low-level API. You can mix both styles in the same program: they share the same transport and can run against the same client. The migration guide walks through moving existing low-level code to the typed API one endpoint at a time.

• Source Code
• API Documentation
• Examples and Recipes

http://www.apache.org/licenses/LICENSE-2.0