Go SDK

github.com/ekoindia/eps-sdk-go is a standard-library-only client for every EPS API. One generic Call(ctx, slug, params) covers all of them: the endpoint catalog, each endpoint's params and which of them are required are embedded in the binary from the same surface these docs are built from, so the client validates your input before it signs and sends anything.

Install

go get github.com/ekoindia/eps-sdk-go

Your first call

Read the two keys from the environment, pick an environment, and call an endpoint by its slug:

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	eps "github.com/ekoindia/eps-sdk-go"
)

func main() {
	client, err := eps.New(eps.Config{
		DeveloperKey: os.Getenv("EPS_DEVELOPER_KEY"),
		AccessKey:    os.Getenv("EPS_ACCESS_KEY"),
		InitiatorID:  "9962981729",
		Environment:  "sandbox",
	})
	if err != nil {
		log.Fatal(err)
	}

	result, err := client.Call(context.Background(), "pan-lite", map[string]any{
		"pan_number": "ABCDE1234F",
		"name":       "Rajesh Kumar",
		"dob":        "1994-08-29",
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(result)
}

InitiatorID and UserCode are near-constant per developer, so set them once in Config. They are injected into every call as the wire params initiator_id and user_code — pass either in params to override it for a single call, or pass nil to clear it.

Client options

API surface

The SDK is deliberately small. There is no method per endpoint — Call() takes the slug, and the embedded surface supplies the method, path, and validation rules. A *Client is safe for concurrent use once constructed.

Authentication

You never compute a signature yourself. On every request the client derives secret-key = base64(HMAC-SHA256(timestamp, base64(AccessKey))) and sends it with secret-key-timestamp and developer_key. eps.Sign is exported only so you can reproduce a signature while debugging a 403.

File uploads

A single type: "file" param flips the whole request to multipart/form-data. You still pass every parameter flat; on the wire the SDK packs them the way the API expects — one form field named form-data holding all the non-file params as a single JSON object, plus one part per upload. A nil param is dropped (a form field has no null encoding), while a nil nested inside a map value is preserved.

File params accept:

• A local file path string
• An eps.File{Name, Content} (or *eps.File) for an in-memory upload

Errors and timeouts

Call returns an error rather than panicking. A non-2xx response comes back as *eps.HTTPError — match it with errors.As and read the decoded envelope off Body. Cancel or deadline any call through its context.Context; the Config.HTTPClient timeout is the outer bound.

Environments

Switch with Config.Environment; there is no base-URL override.

Go-specific notes

• Map keys are sorted before encoding, so query strings and multipart bodies are byte-deterministic.
• The surface is embedded with go:embed, so the package needs no network call to resolve a slug.

Every endpoint

Call() accepts every slug in the EPS catalog. Each endpoint's reference page shows its parameters, response fields and a ready-to-paste Go snippet.