# Go Example for Calling API

### Prerequisites

[You need a valid **API Key** and **API Secret**](/en/getting-started/buy-energy-via-api-on-catfee/api-overview.md#apply-api-info).

Make sure your Go environment has access to standard libraries such as `net/http` and `crypto/hmac`.

### Sample Code

```go
package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/base64"
	"fmt"
	"net/http"
	"net/url"
	"time"
	"io/ioutil"
	"log"
)

const (
	APIKey    = "your_api_key"       // Replace with your actual API Key
	APISecret = "your_api_secret"    // Replace with your actual API Secret
	BaseURL   = "https://api.catfee.io"
)

// Generate the current timestamp in ISO 8601 format
func generateTimestamp() string {
	return time.Now().UTC().Format("2006-01-02T15:04:05.000Z")
}

// Build request path including query parameters
func buildRequestPath(path string, queryParams map[string]string) string {
	if len(queryParams) == 0 {
		return path
	}

	queryString := "?"
	for key, value := range queryParams {
		queryString += fmt.Sprintf("%s=%s&", key, value)
	}
	queryString = queryString[:len(queryString)-1] // remove the trailing '&'
	return path + queryString
}

// Generate HMAC-SHA256 signature
func generateSignature(timestamp, method, requestPath string) string {
	signString := timestamp + method + requestPath
	mac := hmac.New(sha256.New, []byte(APISecret))
	mac.Write([]byte(signString))
	signature := mac.Sum(nil)
	return base64.StdEncoding.EncodeToString(signature)
}

// Create and send HTTP request
func createRequest(url, method, timestamp, signature string) (*http.Response, error) {
	client := &http.Client{}
	req, err := http.NewRequest(method, url, nil)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("CF-ACCESS-KEY", APIKey)
	req.Header.Add("CF-ACCESS-SIGN", signature)
	req.Header.Add("CF-ACCESS-TIMESTAMP", timestamp)

	return client.Do(req)
}

func main() {
	method := "POST" // Can be "GET", "PUT", or "DELETE"
	path := "/v1/order"

	// Example: Create order
	queryParams := map[string]string{
		"quantity": "65000",
		"receiver": "TRON_ADDRESS",
		"duration": "1h",
	}

	timestamp := generateTimestamp()
	requestPath := buildRequestPath(path, queryParams)
	signature := generateSignature(timestamp, method, requestPath)

	url := BaseURL + requestPath

	resp, err := createRequest(url, method, timestamp, signature)
	if err != nil {
		log.Fatal("Error making request:", err)
	}

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal("Error reading response:", err)
	}

	fmt.Println("Response Status:", resp.Status)
	fmt.Println("Response Body:", string(body))
}
```

***

### Code Explanation

#### `generateTimestamp()`

Generates the current UTC time formatted as an ISO 8601 timestamp using Go’s `time` package.

#### `buildRequestPath()`

Takes a map of query parameters and constructs a full query string appended to the request path. Parameters are joined with `&`.

#### `generateSignature()`

Creates a signature string by concatenating `timestamp + method + requestPath`, and then signs it using HMAC-SHA256 with the API Secret. The result is Base64 encoded.

#### `createRequest()`

Builds the HTTP request with appropriate headers (`CF-ACCESS-KEY`, `CF-ACCESS-SIGN`, `CF-ACCESS-TIMESTAMP`) and sends it using the standard `http` package.

#### `main()`

Defines request method and query parameters, generates timestamp, request path, and signature, builds the final URL, and sends the request. Finally, the response is read and printed.

***

### Notes

#### API Key and Secret

Make sure to replace `APIKey` and `APISecret` with your actual credentials from CatFee.IO.

#### Query Parameter Order

This example concatenates query parameters directly without sorting. If your application requires sorted parameters, be sure to implement sorting.

#### Response Handling

The response is read using `ioutil.ReadAll()`. If the response body is in JSON format, consider using the `encoding/json` package to parse the response.

#### HTTP Methods

This example supports `POST`, but you can change it to `GET`, `PUT`, or `DELETE` depending on your needs.

***

### Summary

This example demonstrates how to securely call the CatFee.IO Rest API using Go, including HMAC-SHA256 signature generation for authentication. You can adjust the code to use different HTTP methods and handle various API responses accordingly.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.catfee.io/en/getting-started/buy-energy-via-api-on-catfee/go.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.