DEV Community: Igor

Building Reliable Crypto Alerting Systems in Go: A Deep Dive into the whale-alert-go SDK

Igor — Sat, 25 Jul 2026 07:39:30 +0000

Tracking large cryptocurrency transactions—commonly known as "whales"—has become a crucial tool for traders, analysts, and blockchain researchers. The Whale Alert Enterprise API is one of the leading data providers in this space, offering both historical data and real-time alerts. However, integrating third-party APIs into Go applications often requires writing a significant amount of boilerplate code. Developers must manually implement robust HTTP clients, manage the lifecycle of WebSocket connections, carefully handle pagination, and resolve floating-point precision issues when dealing with financial data.

To address these challenges, the whale-alert-go SDK was created 1. This unofficial Go library is designed specifically for interacting with the Whale Alert Enterprise API. It abstracts away the routine networking tasks, allowing engineers to focus entirely on the business logic of their applications.

Core Philosophy: Idiomatic Go

When designing whale-alert-go, the primary focus was on adhering to the standards and best practices of the Go programming language. Every method that performs a network request accepts a context.Context 1. This ensures proper timeout management and the ability to cancel long-running operations, which is critical for high-load microservices. Furthermore, the client is designed to be entirely concurrency-safe, meaning it can be shared across multiple goroutines without the need for additional mutexes 1.

One of the most common pitfalls when working with cryptocurrency APIs is using the float64 type to represent monetary amounts. Due to the nature of floating-point arithmetic, this inevitably leads to a loss of precision when dealing with very small values (such as satoshi fees) or extremely large numbers. In whale-alert-go, this problem is solved radically: all monetary values and fees are preserved as strings 1. Developers can pass these strings directly into specialized decimal arithmetic packages, such as shopspring/decimal, completely eliminating the risk of data distortion.

REST API: Clean and Resilient

Working with REST APIs often involves network failures, rate limits, and temporary server errors. The SDK provides a powerful retry mechanism that can be configured during client initialization using functional options.

// Create a client with retries enabled: up to 3 attempts, starting at
// 500ms and capped at 10s. Retries only apply to idempotent GET requests.
client := whalealert.NewClient(apiKey,
    whalealert.WithRetry(3, 500*time.Millisecond, 10*time.Second),
)

The retry policy is implemented with safety as the top priority. Only idempotent GET requests are retried, eliminating the risk of duplicating transactions or unintentionally altering state 1. The client automatically responds to HTTP status 429 (Too Many Requests) and 5xx series errors. It uses an exponential backoff strategy with added jitter (random deviation) to prevent the "thundering herd" effect, and it also respects the Retry-After header if provided by the server 1.

WebSocket Alerts: Built to Survive

For real-time data delivery, Whale Alert provides a WebSocket API. Maintaining long-lived connections is a complex task because networks are inherently unstable and servers may forcefully drop sessions. The websocket package included in the SDK offers an elegant solution with automatic reconnection capabilities 1.

client := websocket.NewClient(websocket.Config{
    URL: wsURL,
    Reconnect: websocket.ReconnectConfig{
        MaxAttempts:  5,
        InitialDelay: 1 * time.Second,
        MaxDelay:     30 * time.Second,
    },
})

client.OnMessage(func(msg websocket.Message) {
    if msg.EventType == websocket.EventTypeAlert && msg.Alert != nil {
        fmt.Printf("[ALERT] %s: %s\n", msg.Alert.Blockchain, msg.Alert.Text)
    }
})

A developer simply needs to define the reconnection parameters and register handlers for messages and errors. The client independently manages the read loop, decodes incoming events into strongly typed structs, and handles ping/pong control messages to keep the connection alive 1.

Safe Pagination and Error Handling

Endpoints that return lists, such as transaction histories, require pagination. whale-alert-go offers two approaches. The first is a lazy TransactionIterator that hides the logic of fetching subsequent pages under the hood 1. The second approach allows developers to manually manage navigation using the Next URL links.

A notable security feature of the SDK is its validation of URLs for subsequent pages. The library verifies that the Next URL shares the same origin as the client's base URL, preventing potential redirection attacks to malicious servers 1.

Error handling is also executed in the best traditions of Go 1.13+. The API returns a typed APIError containing the HTTP status and the message from the server. In addition, sentinel errors such as ErrUnauthorized or ErrRateLimited are provided, which can be easily checked using errors.Is and errors.As 1.

Conclusion

Integrating with financial and cryptocurrency APIs demands a high degree of reliability. The whale-alert-go library provides developers with a ready-to-use, carefully designed toolkit that resolves issues related to network instability, data precision loss, and connection management. Thanks to strongly typed models and an idiomatic approach, writing code becomes faster and safer.

You can install the library using the standard Go command:

go get github.com/tigusigalpa/whale-alert-go

Please note that this is an unofficial SDK, and you will need a valid Whale Alert Enterprise API key to access authenticated endpoints. Check out the source code, examples, and full documentation in the project's GitHub repository.

References

Track Blockchain Whale Activity in PHP with whale-alert-php

Igor — Thu, 23 Jul 2026 06:10:20 +0000

Large on-chain transfers are valuable events for monitoring, analytics, and alerting workflows. A product may need to retrieve a historical transaction, inspect the synchronization status of a blockchain, or notify a team the moment a high-value transfer appears. In PHP, those needs can quickly turn into repetitive work: composing requests, parsing responses, treating money safely, retrying temporary failures, and maintaining a live WebSocket connection.

That is the problem whale-alert-php is designed to solve. It is an unofficial, MIT-licensed PHP client for the Whale Alert Enterprise API, with coverage for documented REST endpoints and real-time WebSocket alerts. Rather than exposing a loose collection of arrays and request helpers, the library presents a typed, immutable, and framework-friendly interface for PHP applications. 1

Important: whale-alert-php is an independent, unofficial SDK. It is not affiliated with, endorsed by, or sponsored by Whale Alert. A valid API key is required for authenticated API operations. 1

Why a dedicated PHP SDK matters

Integrating an external blockchain-data API is not difficult in the narrowest sense: an HTTP request can return JSON in a few lines. The engineering work begins after that request. Production code must decide how to represent token quantities, distinguish a missing API key from a rate-limit response, follow a paginated result safely, and recover from a short-lived network or provider failure.

whale-alert-php packages those concerns into a focused client. Monetary values and fees are deliberately returned as strings rather than PHP floats, protecting applications from silent precision loss. API responses are mapped to immutable DTOs, while failures are exposed through typed exceptions. The client can use any PSR-18 compatible HTTP implementation, and Laravel applications can opt into a service provider, configuration publishing, a facade, and dependency injection. 1

Capability	What the SDK provides	Practical benefit
REST API access	Methods for supported blockchains, blockchain status, transactions, blocks, and address transactions. 1	Build historical views and data-enrichment workflows without hand-writing endpoint wrappers.
Real-time WebSocket events	Alert and social-event streaming, subscriptions, decoded messages, ping/pong keep-alives, and optional reconnection. 1	React to relevant on-chain activity as it arrives.
Typed, immutable DTOs	Structured response objects instead of ad hoc response arrays. 1	Improve autocomplete, readability, and confidence when integrating the API.
Precision-aware amounts	Fees and monetary fields remain strings. 1	Avoid float-rounding surprises in financial or analytical code.
Resilience controls	Configurable exponential-backoff retries for idempotent GET requests on HTTP 429 and 5xx responses. 1	Make short-lived API or network failures less disruptive.
Laravel integration	Optional service provider, facade, configuration publishing, and singleton client binding. 1	Add the SDK naturally to Laravel projects without sacrificing dependency injection.

Install it with Composer

The fastest path is a standard Composer install:

composer require tigusigalpa/whale-alert-php

The package uses Guzzle by default, but its PSR-18 design lets an application substitute another compatible HTTP client when needed. That is useful for teams with an existing HTTP stack or a deliberate preference for a different client implementation. 1

Start with the REST API

The following example creates a client, lists the blockchains supported by the public status endpoint, fetches Ethereum synchronization status, and retrieves a page of transactions. The code follows the library's documented API surface. 1

use Tigusigalpa\WhaleAlert\Config;
use Tigusigalpa\WhaleAlert\WhaleAlertClient;

$config = new Config(
    apiKey: getenv('WHALE_ALERT_API_KEY'),
    maxRetries: 3,
);

$client = new WhaleAlertClient($config);

// Public endpoint: an API key is not required here.
$chains = $client->getSupportedBlockchains();

foreach ($chains as $chain) {
    echo $chain->getName() . ': ' . implode(', ', $chain->getSymbols()) . "\n";
}

// Authenticated endpoint: supply a valid API key.
$status = $client->getBlockchainStatus('ethereum');

echo "Ethereum: {$status->getStartHeight()}-{$status->getEndHeight()}\n";

$page = $client->listTransactions('ethereum', [
    'start_height' => $status->getStartHeight(),
    'limit' => 100,
]);

foreach ($page->getTransactions() as $tx) {
    echo "Transaction {$tx->getHash()}\n";
    echo "Fee: {$tx->getFee()} {$tx->getFeeSymbol()}\n";
}

The key detail is not merely that the calls are concise. The return values are DTOs, so readers of the code can see that a transaction hash and fee are part of an explicit API contract. Since fee values are strings, the application can display them as received or use a decimal-math library for precise calculations rather than implicitly converting them to floats. 1

Make pagination a safe default

Pagination is often treated as a trivial concern until it becomes a security or reliability issue. List calls return a TransactionPage that contains the current transactions and an optional next URL. When the next page exists, the client can follow it with listTransactionsNext(). The SDK validates next URLs against the configured base origin, which avoids accidentally following an arbitrary URL returned in a response. Equivalent helpers are available for address-transaction pagination. 1

if ($page->getNext() !== null) {
    $nextPage = $client->listTransactionsNext($page->getNext());

    foreach ($nextPage->getTransactions() as $tx) {
        echo $tx->getHash() . "\n";
    }
}

For applications that process large transaction sets, this small design choice keeps the calling code readable while retaining an important validation boundary.

Stream real-time alerts with WebSockets

Polling has its place, but a real-time alerting product should not have to wait for the next scheduled request. whale-alert-php includes a WebSocket client that lets an application connect, subscribe to alerts, register handlers, and enter a read loop. Automatic reconnection is opt-in: configure maxReconnects with a value greater than zero when that behavior is appropriate for the application. 1

Here is a compact example that listens for Ethereum alerts with a minimum USD value of 500,000:

use Tigusigalpa\WhaleAlert\WebSocket\AlertSubscription;
use Tigusigalpa\WhaleAlert\WebSocket\Client;
use Tigusigalpa\WhaleAlert\WebSocket\EventType;

$apiKey = getenv('WHALE_ALERT_API_KEY');
$wsUrl = sprintf(
    'wss://leviathan.whale-alert.io/ws?api_key=%s',
    $apiKey,
);

$client = new Client($wsUrl, maxReconnects: 5);

$client->onMessage(function ($message) {
    if ($message->type === EventType::Alert && $message->alert !== null) {
        echo "Blockchain: {$message->alert['blockchain']}\n";
        echo "Alert: {$message->alert['text']}\n";
    }
});

$client->onError(function (\Throwable $exception) {
    fwrite(STDERR, "Connection issue: {$exception->getMessage()}\n");
});

$client->connect();

$client->subscribeAlerts(new AlertSubscription(
    id: 'eth-whale-watch',
    blockchains: ['ethereum'],
    minValueUsd: 500000,
));

$client->listen();

This is a useful foundation for an internal operations feed, a Discord or Telegram notification bridge, a data-ingestion worker, or a real-time dashboard. The SDK takes responsibility for the WebSocket protocol mechanics—connection, subscription management, message decoding, keep-alives, and optional reconnection—so the application can focus on what should happen after an alert is received. 1

Handle failures intentionally

A reliable integration should make it easy to tell a configuration mistake from a temporary upstream problem. The SDK maps API failures to named exception types, including UnauthorizedException for an invalid or missing credential, RateLimitException for HTTP 429 responses, NotFoundException, validation errors, and server-side errors. 1

use Tigusigalpa\WhaleAlert\Exceptions\ApiException;
use Tigusigalpa\WhaleAlert\Exceptions\RateLimitException;
use Tigusigalpa\WhaleAlert\Exceptions\UnauthorizedException;

try {
    $status = $client->getBlockchainStatus('ethereum');
} catch (UnauthorizedException $exception) {
    // Check WHALE_ALERT_API_KEY.
} catch (RateLimitException $exception) {
    // Use the provider's suggested retry timing when present.
    $retryAfter = $exception->getRetryAfter();
} catch (ApiException $exception) {
    // Log or handle other API-specific failures.
}

The retry strategy is intentionally conservative. It is disabled by default, applies only to idempotent GET requests, retries rate-limit and 5xx responses, uses exponential backoff with jitter, and can honor a Retry-After header. The library also redacts api_key values from error excerpts and does not log the key itself. 1

Configuration option	Default	Role
`apiKey`	Empty string	Sets the credential used for authenticated endpoints. 1
`timeout`	`30` seconds	Defines the HTTP timeout. 1
`maxRetries`	`0`	Enables retry attempts for eligible GET requests when set above zero. 1
`retryDelayMs`	`500` ms	Sets the initial delay used by exponential backoff. 1
`retryMaxDelayMs`	`10000` ms	Caps the retry delay. 1

A natural fit for Laravel

For Laravel projects, the optional WhaleAlertServiceProvider can publish a config/whale-alert.php file and register WhaleAlertClient as a singleton. Developers can then either use the WhaleAlert facade or request WhaleAlertClient through dependency injection. That offers a clean path from a simple prototype to maintainable application code. 1

use Tigusigalpa\WhaleAlert\WhaleAlertClient;

public function index(WhaleAlertClient $client)
{
    $chains = $client->getSupportedBlockchains();

    return view('chains.index', compact('chains'));
}

The project also contains runnable REST and WebSocket examples plus PHPUnit tests covering the REST client, WebSocket client, DTOs, and error handling. Those resources make it easier to evaluate the package before embedding it in a broader workflow. 1

Build the blockchain feature, not the plumbing

whale-alert-php is for PHP teams that want to work with Whale Alert Enterprise API data without rebuilding the client layer from scratch. Its value is in the details that application code should not need to rediscover: PSR-18 flexibility, immutable typed responses, string-safe monetary fields, explicit error types, controlled retries, guarded pagination, and real-time WebSocket support. 1

If you are building a PHP or Laravel tool that monitors, enriches, visualizes, or routes blockchain-transfer events, install the SDK, review the examples, and tailor the subscriptions and request flow to your use case. Visit the GitHub repository for the complete README, source code, and release information. 1

References

Supercharge Your Algorithmic Trading with CoinQuant PHP: The Ultimate SDK for Laravel and PHP 8.1+

Igor — Tue, 21 Jul 2026 18:35:38 +0000

Are you tired of wrestling with raw cURL requests, parsing Server-Sent Events (SSE) by hand, and building complex polling loops just to interact with trading APIs? If you are a PHP developer or a Laravel enthusiast looking to dive into algorithmic trading, your life is about to get a whole lot easier. Meet coinquant-php, the official PHP and Laravel SDK for the CoinQuant Public API.

CoinQuant is revolutionizing the way we approach algorithmic trading. It takes a trading idea described in plain English and turns it into a backtestable strategy using advanced AI. However, integrating such powerful tools into your own applications can often be a daunting task. That is where coinquant-php steps in. This robust SDK wraps the public API, providing a seamless, developer-friendly experience that lets you focus on what really matters: building profitable trading strategies.

In this comprehensive guide, we will explore why coinquant-php is a game-changer for PHP developers, delve into its standout features, and show you how to get started in minutes.

Why Choose CoinQuant PHP?

The landscape of algorithmic trading is often dominated by Python, but PHP remains a powerhouse for web development, especially with frameworks like Laravel. coinquant-php bridges the gap, allowing PHP developers to leverage the cutting-edge AI capabilities of CoinQuant without leaving their preferred ecosystem.

1. Built for Modern PHP

The library is designed for the modern era of PHP. It requires PHP 8.1+ and embraces strict typing, ensuring your code is robust and free from legacy baggage. Whether you are building a standalone script or a complex enterprise application, the SDK provides a solid foundation.

2. First-Class Laravel Integration

If you are using Laravel 10, 11, 12, or 13, you are in for a treat. The package auto-registers its ServiceProvider and Facade, meaning there is absolutely zero manual wiring required. You can simply install the package and start using the CoinQuant facade anywhere in your controllers, jobs, or commands. It also binds the client as a singleton for elegant dependency injection.

3. Comprehensive API Coverage

The SDK doesn't just cover the basics; it provides access to all 37 public endpoints of the CoinQuant API. This includes health checks, chat interactions, strategy generation, versioning, backtesting, reports, templates, credit management, and even community features like leaderboards. Everything you need is right at your fingertips.

4. Effortless Streaming via Generators

One of the most powerful features of CoinQuant is its AI engine, which responds over Server-Sent Events (SSE). Handling SSE in PHP can be tricky, but the SDK abstracts this away completely. It reads the stream and classifies events into categories like chat, strategy, report, error, or unknown. You can even iterate over the generator directly to stream tokens to a browser in real-time, creating a highly responsive user experience.

5. Simplified Backtesting

Backtesting is the core of algorithmic trading, and coinquant-php makes it incredibly simple. The createBacktestAndWait() method is a one-call solution that submits the run, polls until completion, and returns the final results along with CSV exports for deep analysis.

6. Actionable Exceptions

Debugging API integrations can be frustrating, but not with this SDK. Any non-2xx response throws a CoinQuantException that carries the HTTP status, a unique request_id, a machine-readable code, and a descriptive message. This makes error handling and troubleshooting a breeze.

Getting Started: From Zero to Backtest

Let's walk through how easy it is to get started with coinquant-php.

Installation

First, pull the package in via Composer. Guzzle, the underlying HTTP client, is installed automatically.

composer require tigusigalpa/coinquant-php

Configuration

CoinQuant uses a JWT bearer token for authentication. You can generate one from the Settings menu in the CoinQuant web app. Keep this token secure in an environment variable (COINQUANT_TOKEN).

For standalone PHP:

use CoinQuant\CoinQuantClient;

$client = new CoinQuantClient(getenv('COINQUANT_TOKEN'));
$credits = $client->getCredits();

echo "Available credits: {$credits['available_credits_total']}";

For Laravel, simply add the token to your .env file:

COINQUANT_TOKEN=your_token_here

And you are ready to use the facade:

use CoinQuant\Laravel\Facades\CoinQuant;

$credits = CoinQuant::getCredits();

The Workflow: Idea to Metrics

The true power of the SDK shines when you use it to turn an idea into a fully backtested strategy. Here is a complete workflow in just a few lines of code:

// 1. Describe the idea and let the AI draft a strategy.
$res = $client->prompt('Long BTCUSDT when price crosses above the 200 EMA on 1h, exit on cross below.');

// 2. Materialize it if it came back schema-only.
$versionId = $res->strategyVersionId
    ?? $client->finalizeChat($res->chatId, 'EMA 200 Crossover', '')['latest_version']['id'];

// 3. Backtest and wait for the verdict.
$outcome = $client->createBacktestAndWait($versionId, 900, 5);

// 4. Analyze the results
print_r($outcome['results']['metrics']);

In this example, we simply ask the AI to create a strategy based on the 200 EMA crossover. The SDK handles the streaming response, materializes the strategy blueprint into a backtestable version, runs the backtest, and polls for the results. It is algorithmic trading made remarkably accessible.

Advanced Usage: Streaming and Customization

For developers who need more control, coinquant-php delivers.

Real-Time Streaming

If you are building a user interface and want to show the AI's thought process in real-time, you can iterate the generator directly:

use CoinQuant\Streaming\StreamEvent;

foreach ($client->streamPrompt('Explain the RSI indicator.') as $event) {
    if ($event->type === StreamEvent::TYPE_CHAT) {
        echo $event->text; // Flush to the client in real time
    }
}

Custom HTTP Clients

Under the hood, the SDK uses Guzzle. If you need to configure retries, route traffic through a proxy, or add custom headers for tracing, you can pass your own configured Guzzle client:

use GuzzleHttp\Client as GuzzleClient;

$http = new GuzzleClient([
    'timeout' => 60,
    'headers' => ['Authorization' => 'Bearer ' . getenv('COINQUANT_TOKEN' )],
]);

$client = new CoinQuantClient(getenv('COINQUANT_TOKEN'), $http );

Conclusion

The coinquant-php SDK is a masterclass in developer experience. By abstracting away the complexities of the CoinQuant API, SSE parsing, and asynchronous polling, it empowers PHP developers to build sophisticated trading applications with unprecedented speed and ease.

Whether you are a solo developer exploring algorithmic trading or a team building a comprehensive financial platform on Laravel, this SDK provides the tools you need to succeed. The strict typing, elegant Laravel integration, and comprehensive endpoint coverage make it a joy to use.

Ready to turn your trading ideas into reality? Head over to the GitHub repository, give it a star, and start building today!

Happy Coding and Happy Trading!

Repository Author: Igor Sazonov (@tigusigalpa)License: MIT

Build AI-Powered Trading Strategies in Go with CoinQuant-Go

Igor — Tue, 21 Jul 2026 07:23:32 +0000

Algorithmic trading has traditionally been a domain characterized by high barriers to entry. Quants and developers spend countless hours writing boilerplate code to handle HTTP requests, parse complex JSON responses, and manage Server-Sent Events (SSE) streams. However, the landscape is rapidly evolving with the integration of Artificial Intelligence into trading workflows. CoinQuant is at the forefront of this revolution, offering a platform where you can describe a trading idea in plain English and let AI turn it into a backtestable strategy.

But what if you want to integrate this powerful AI engine directly into your Go applications? Enter coinquant-go, a comprehensive, community-driven Go client for the CoinQuant Public API. In this article, we will explore why coinquant-go is the ultimate tool for Go developers looking to build, backtest, and deploy algorithmic trading strategies with AI in the loop.

The Problem with API Boilerplate

When integrating third-party APIs into Go applications, developers often face a repetitive and error-prone process. Writing HTTP clients, managing context timeouts, handling retries, and parsing nested JSON responses can quickly bloat your codebase. This is especially true for platforms like CoinQuant, which rely heavily on streaming responses via Server-Sent Events (SSE) to deliver real-time AI-generated content.

Without a dedicated SDK, developers are forced to write custom parsers for raw event frames, handle connection drops, and manually map JSON structures to Go structs. This not only slows down development but also increases the likelihood of runtime errors. coinquant-go solves this problem by providing an intentionally thin, idiomatic Go wrapper around the CoinQuant API, allowing you to focus on your trading logic rather than the underlying plumbing.

Why Choose CoinQuant-Go?

coinquant-go is designed with the Go developer in mind. It embraces the language's core principles of simplicity, strong typing, and concurrency. Here are the key features that make it stand out:

1. Idiomatic Go Design

Every function in coinquant-go takes a context.Context as its first argument, adhering to Go's standard practices for cancellation and timeout management. Requests and responses are defined as concrete structs with explicit json tags. This means you never have to deal with the guesswork and type assertions associated with map[string]any. The strongly typed nature of the library ensures compile-time safety and excellent IDE support.

2. Comprehensive API Coverage

The library provides full coverage of all 37 public endpoints offered by CoinQuant. Whether you need to check your credit balance, manage chat sessions, create strategies, run backtests, or fetch research reports, coinquant-go has a dedicated, strongly typed method for it. You have complete programmatic control over your CoinQuant account.

3. Robust SSE Streaming

One of the most challenging aspects of working with AI APIs is handling streaming responses. coinquant-go abstracts away the complexity of parsing raw SSE frames. It provides a callback-driven streaming interface for endpoints like POST /v1/prompts/stream and POST /v1/chats/{chat_id}/messages:stream.

The library automatically reads the stream, passes each event to your callback function as it arrives, and returns a classified StreamResult when the stream closes. Events are intelligently classified into error, strategy, report, chat, or unknown using CoinQuant's own precedence rules, making it incredibly easy to handle different types of AI responses.

4. Seamless Backtesting Workflows

Running backtests is a core part of developing trading strategies. coinquant-go simplifies this process with the CreateBacktestAndWait function. This utility method wraps the entire backtesting lifecycle: it submits a strategy version for testing, polls the API at regular intervals until a terminal state is reached (such as completed, failed, or error), and returns the final results along with the raw CSV exports. This eliminates the need to write custom polling loops in your application code.

5. Schema-Only Materialization

Sometimes, the CoinQuant AI returns a strategy schema without a specific version ID. This acts as a blueprint rather than a runnable strategy. coinquant-go provides a convenient FinalizeChat method that takes this schema and materializes it into a real, versioned strategy that is ready for backtesting.

6. Actionable Error Handling

Error handling is critical in financial applications. coinquant-go converts every non-2xx HTTP response into a typed *APIError. This struct contains the HTTP status code, a machine-readable error code, a human-readable message, and a unique request_id. By using errors.As, you can easily inspect the error and implement appropriate retry logic or notify the user. The request_id is particularly useful when reaching out to CoinQuant support for troubleshooting.

Getting Started with CoinQuant-Go

Let's dive into some code to see how easy it is to use coinquant-go.

Installation

First, install the package using go get. Note that the library requires Go 1.22 or newer.

go get github.com/tigusigalpa/coinquant-go

Initializing the Client

To interact with the API, you need a JWT bearer token from your CoinQuant account. You can generate this token in the CoinQuant web app under Settings → Service Accounts → New key.

package main

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

    coinquant "github.com/tigusigalpa/coinquant-go"
)

func main() {
    // Initialize the client with your secret token
    client := coinquant.NewClient(os.Getenv("COINQUANT_TOKEN"))
    ctx := context.Background()

    // Fetch your available credits
    credits, err := client.GetCredits(ctx)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Available Credits:", credits.AvailableCreditsTotal)
}

The client is highly configurable. You can use functional options to override the base URL, set custom timeouts, or inject your own *http.Client for tracing and proxies.

client := coinquant.NewClient(
    os.Getenv("COINQUANT_TOKEN" ),
    coinquant.WithTimeout(60*time.Second),
    coinquant.WithHTTPClient(myCustomClient),
)

Streaming an AI Prompt

Let's ask the CoinQuant AI to generate a trading strategy and stream the response to the console in real-time.

result, err := client.StreamPrompt(ctx, coinquant.StreamingPromptRequest{
    Message: "Generate a BTCUSDT 1h EMA crossover strategy.",
}, func(ev coinquant.StreamEvent) error {
    // Print each chunk of text as it arrives
    fmt.Print(ev.Text)
    return nil
})
if err != nil {
    log.Fatal(err)
}

fmt.Println("\n\nResponse classified as:", result.Type)

The library automatically classifies the response. If the AI generated a strategy, result.Type will be coinquant.StreamTypeStrategy.

The Complete Workflow: From Idea to Metrics

Here is a complete, end-to-end example of generating a strategy, materializing it, running a backtest, and fetching the results.

// 1. Describe the idea and let the AI draft a strategy.
res, _ := client.StreamPrompt(ctx, coinquant.StreamingPromptRequest{
    Message: "Long BTCUSDT when price crosses above the 200 EMA on 1h, exit on cross below.",
}, nil)

// 2. Materialize the strategy if it came back schema-only.
versionID := ""
if res.StrategyVersionID != nil {
    versionID = *res.StrategyVersionID
} else if res.ChatID != nil {
    s, _ := client.FinalizeChat(ctx, *res.ChatID, "EMA 200 Crossover", "")
    versionID = s.LatestVersion.ID
}

// 3. Run the backtest and wait for completion (900s timeout, 5s poll interval).
bt, err := client.CreateBacktestAndWait(ctx, versionID, 900, 5)
if err != nil {
    log.Fatal("Backtest failed:", err)
}

// 4. Print the performance metrics.
fmt.Println("Backtest Status:", bt.Detail.Status)
if bt.Results != nil {
    fmt.Printf("Total Return: %v%%\n", bt.Results.Metrics["Total Return"])
    fmt.Printf("Sharpe Ratio: %v\n", bt.Results.Metrics["Sharpe Ratio"])
}

With just a few lines of Go code, we have interacted with a sophisticated AI engine, generated a trading algorithm, tested it against historical data, and retrieved the performance metrics.

Conclusion

coinquant-go bridges the gap between the power of the CoinQuant AI platform and the robust ecosystem of the Go programming language. By providing an idiomatic, strongly typed, and feature-complete SDK, it empowers developers to build complex algorithmic trading systems without getting bogged down by API intricacies.

Whether you are building a custom trading bot, an automated research tool, or integrating AI-driven insights into an existing financial application, coinquant-go provides the solid foundation you need.

Head over to the GitHub repository to check out the source code, read the full API reference, and start building your AI-powered trading strategies today!

Note: *coinquant-go** is an unofficial community package and is not maintained or endorsed by CoinQuant.*

Building High-Performance Crypto Trading Bots with Go: Meet phemex-go

Igor — Sun, 19 Jul 2026 11:54:35 +0000

If you are building a cryptocurrency trading bot, market maker, or data aggregator in Go, you already know that talking to an exchange's API should be the least of your worries. Your focus needs to be on strategy, risk management, and execution speed. Unfortunately, many exchange SDKs are either auto-generated and unidiomatic, bloated with third-party dependencies, or missing crucial features like automatic request signing and resilient WebSockets.

Enter phemex-go — a friendly, batteries-included Golang SDK for the Phemex crypto exchange.

Whether you want to trade spot, perpetuals (USDⓈ-M and Coin-M), or margin, stream live market data, or manage your wallets, phemex-go provides a clean, idiomatic, and robust foundation for your Go applications.

In this article, we will explore why phemex-go stands out, how its core architecture simplifies exchange interactions, and walk through practical examples of using its REST and WebSocket APIs.

Why Choose `phemex-go`?

Talking to a crypto exchange should feel boring — in the best possible way. No surprises, no leaked goroutines, no mystery around request signing. That's exactly what phemex-go is built for.

Here is what makes it a compelling choice for Go developers:

Contexts Everywhere: Every REST and WebSocket call takes a context.Context. This means cancellation, deadlines, and graceful shutdown work exactly as you expect them to in modern Go applications.
Invisible Request Signing: Private requests require HMAC SHA256 signatures. phemex-go handles this automatically. You never have to manually touch a timestamp or construct a signature header.
Resilient WebSocket Client: Networks drop. Servers hiccup. The phemex-go WebSocket client is built for the real world. It reconnects on its own, keeps the connection alive with heartbeats, and delivers events over plain Go channels.
Domain-Driven Design: The API is huge, but the SDK is organized logically. Market data, spot, USDⓈ-M, Coin-M, margin, and assets each live in their own small, focused package.
Featherweight Dependencies: The only third-party dependency is gorilla/websocket. Everything else relies on the Go standard library, keeping your module graph clean and secure.
Fully Tested: Signature generation and the REST layer are covered by unit tests and httptest mocks, ensuring reliability without hitting live endpoints during your CI/CD pipeline.
Typed Error Handling: Stop parsing error strings. phemex-go provides typed errors (e.g., RateLimitError, AuthenticationError ), allowing you to handle edge cases programmatically.

Getting Started

Installation

To start using phemex-go, you need Go 1.21 or newer. Install the package using go get:

go get github.com/tigusigalpa/phemex-go

Then, import the core package along with the specific domain packages you need:

import (
    "github.com/tigusigalpa/phemex-go"
    "github.com/tigusigalpa/phemex-go/market"
    "github.com/tigusigalpa/phemex-go/spot"
)

Core Architecture

A little mental model goes a long way. The SDK is split into two primary layers:

The Core Client (phemex.NewClient): This layer owns the HTTP transport, credentials, signing logic, retries, and error mapping.
Domain Clients (market.NewClient, **spot.NewClient***, etc.):* These are thin, typed wrappers around the core client, specific to an API area.

You create the core client once and share it across as many domain clients as you need. It is completely safe for concurrent use.

core := phemex.NewClient(phemex.Config{
    APIKey:    os.Getenv("PHEMEX_API_KEY"),
    APISecret: os.Getenv("PHEMEX_API_SECRET"),
})

spotClient := spot.NewClient(core)
usdtmClient := usdtm.NewClient(core)
assetsClient := assets.NewClient(core)

Exploring the REST API

The library mirrors Phemex's API structure. Let's look at some common use cases.

Fetching Public Market Data

Public market data endpoints work without credentials, making them great for prototyping and read-only tools.

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/tigusigalpa/phemex-go"
    "github.com/tigusigalpa/phemex-go/market"
)

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

    // Initialize core and domain client
    c := market.NewClient(phemex.NewClient(phemex.Config{}))

    // Fetch the order book snapshot for BTCUSD
    book, err := c.OrderBook(ctx, "BTCUSD")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Order Book:", book)

    // Fetch candlesticks (klines) with a typed request
    limit := int64(100)
    klines, err := c.Kline(ctx, market.KlineRequest{
        Symbol:     "BTCUSDT",
        Resolution: "1h",
        Limit:      &limit,
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Klines:", klines)
}

Placing a Spot Trade

For anything that touches your account—placing orders, reading balances, transferring funds—you must provide an API key and secret.

package main

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

    "github.com/tigusigalpa/phemex-go"
    "github.com/tigusigalpa/phemex-go/spot"
)

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

    client := spot.NewClient(phemex.NewClient(phemex.Config{
        APIKey:    os.Getenv("PHEMEX_API_KEY"),
        APISecret: os.Getenv("PHEMEX_API_SECRET"),
    }))

    // Place a limit buy order
    resp, err := client.CreateOrder(ctx, map[string]any{
        "symbol":   "BTCUSDT",
        "side":     "Buy",
        "ordType":  "Limit",
        "price":    "65000",
        "orderQty": "0.001",
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Order placed:", resp)

    // Review open orders
    open, err := client.QueryOpenOrders(ctx, "BTCUSDT")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Open orders:", open)
}

Streaming Real-Time Data with WebSockets

The ws package provides a resilient, real-time feed. It automatically reconnects after drops, sends periodic heartbeats to keep the socket healthy, replays your subscriptions on reconnect, and delivers every message over a Go channel.

package main

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

    "github.com/tigusigalpa/phemex-go/ws"
)

func main() {
    client := ws.NewClient(ws.Config{
        // Credentials are only needed for private channels like 'aop'
        APIKey:    os.Getenv("PHEMEX_API_KEY"),
        APISecret: os.Getenv("PHEMEX_API_SECRET"),
    })

    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    // Connect to the WebSocket
    if err := client.Connect(ctx); err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    // Subscribe to the order book for a symbol
    if err := client.Subscribe(ctx, "orderbook", "BTCUSDT"); err != nil {
        log.Fatal(err)
    }

    // Consume events as they arrive
    for ev := range client.Events() {
        fmt.Printf("%+v\n", ev)
    }
}

When you provide credentials, the client authenticates with a user.auth message before your subscriptions go out, ensuring private channels like aop (Account / Order / Position updates) are ready to use immediately.

Smart Error Handling and Retries

One of the standout features of phemex-go is its intelligent error handling. Rate limits (HTTP 429) and server errors (HTTP 5xx) are retried automatically with exponential backoff, honoring the Retry-After header when present.

When an error does reach your code, it is strongly typed, allowing for precise control flow:

resp, err := client.CreateOrder(ctx, params)
if err != nil {
    switch e := err.(type) {
    case *phemex.RateLimitError:
        log.Printf("Slow down — retry after %v", e.RetryAfter)
    case *phemex.AuthenticationError:
        log.Fatal("Check your API key and secret")
    case *phemex.ValidationError:
        log.Printf("The request was rejected: %s", e.Message)
    case *phemex.NotFoundError:
        log.Printf("Resource not found: %s", e.Message)
    case *phemex.APIError:
        log.Printf("Phemex error %d: %s", e.StatusCode, e.Message)
    default:
        log.Printf("Unexpected error: %v", err)
    }
}

Conclusion

Building a crypto trading system requires a solid foundation. You shouldn't have to write your own request signing logic, implement exponential backoff for rate limits, or manage WebSocket reconnection loops.

phemex-go abstracts away the boilerplate of interacting with the Phemex exchange, providing a fast, idiomatic, and highly reliable Go SDK. Whether you are building a high-frequency trading bot, a portfolio tracker, or a market data aggregator, phemex-go gives you the tools you need to succeed.

Check out the repository on GitHub, star the project, and dive into the examples/ directory to see it in action!

GitHub Repository: https://github.com/tigusigalpa/phemex-goAuthor: Igor Sazonov (@tigusigalpa)License: MIT

Disclaimer: Trading cryptocurrencies carries significant risk. This library is provided as-is. Test thoroughly—ideally against the Phemex testnet—before running anything with real money.

Stop Wrestling with cURL: The Modern PHP Client for Phemex Crypto Trading

Igor — Sun, 19 Jul 2026 10:59:37 +0000

Trading cryptocurrency programmatically is an exciting endeavor, but it often comes with a steep learning curve. When you decide to integrate a cryptocurrency exchange API into your PHP application, you quickly realize that executing trades is only half the battle. The other half involves wrestling with raw cURL requests, managing complex HMAC SHA256 signatures, mapping JSON responses, and handling rate limits. This plumbing can drain your time and distract you from what truly matters: your trading strategy.

Enter phemex-php, a modern, strictly typed PHP client for the Phemex cryptocurrency exchange API created by Igor Sazonov. Designed for PHP 8.1+ and offering first-class Laravel integration, this open-source package transforms the Phemex REST API into a clean, object-oriented interface. In this article, we will explore why phemex-php is the missing piece in your crypto trading stack and how it simplifies building robust trading bots and applications.

The Challenge of Crypto API Integration

Integrating with a cryptocurrency exchange like Phemex 1 requires developers to navigate several technical hurdles. First and foremost is authentication. Private endpoints demand proper HMAC SHA256 signing, which involves concatenating the URL path, query string, expiry time, and request body, and then hashing it with your API secret 2. A single misplaced character or incorrect timestamp will result in an authentication failure.

Secondly, developers must handle rate limits gracefully. Exchanges enforce strict request quotas to protect their infrastructure 2. When you hit a rate limit (HTTP 429), your application needs to catch the error, read the retry-after headers, and implement exponential backoff before attempting the request again.

Finally, there is the issue of type safety and response mapping. Raw JSON responses are prone to typos and lack IDE auto-completion. Without a robust data transfer object (DTO) layer, maintaining and scaling your application becomes a nightmare.

Why Choose phemex-php?

The phemex-php package addresses these challenges head-on, offering a developer experience that is both powerful and intuitive. Let's delve into the core features that make this library stand out.

1. Strictly Typed and Future-Proof

Built for PHP 8.1+, the library leverages modern PHP features such as typed properties, return types, and named arguments. Every API response is wrapped in a DTO. This means you get full IDE auto-completion for response fields, significantly reducing the risk of runtime errors.

Moreover, the DTOs are designed to preserve the raw payload. If Phemex adds new fields to their API responses, you can still access them without waiting for the library to be updated. This future-proof design ensures your application remains stable even as the exchange evolves.

2. Framework-Agnostic with First-Class Laravel Support

At its core, phemex-php is framework-agnostic. It uses PSR-18 for HTTP communication, meaning it can run in any PHP environment 3. However, if you are a Laravel developer, you are in for a treat. The package ships with auto-discovered service providers, publishable configuration files, and a convenient Phemex facade for Laravel 10–13.

This dual approach ensures that whether you are building a lightweight standalone script or a massive Laravel application, the library integrates seamlessly.

3. Automatic HMAC Signing and Rate Limit Handling

Security and stability are built into the library by default. Private endpoints are signed automatically using the official Phemex HMAC SHA256 algorithm. You never have to worry about constructing the signature string yourself.

Furthermore, the library features automatic retries for rate limits (HTTP 429) and transient server errors. It implements exponential backoff, ensuring your application respects the exchange's limits while maximizing the chances of a successful request.

4. Bring Your Own HTTP Client

By default, the library uses Guzzle, the industry standard for HTTP requests in PHP. However, because it adheres to the PSR-18 standard, you can inject any compatible HTTP client. This flexibility is crucial for unit testing, as it allows you to mock HTTP responses without making actual network calls, or for adding custom middleware, logging, and metrics to your requests.

5. Comprehensive Endpoint Coverage

The phemex-php library provides extensive coverage of the Phemex REST API. Endpoints are logically grouped into dedicated methods on the client, making navigation a breeze:

Group	Client Method	Covered Endpoints
Market Data	`$client->market()`	Products, orderbook, kline, trades, 24h tickers, funding rate history
Spot Trading	`$client->spot()`	Create, amend, cancel orders, wallets, order/trade history
USDⓈ-M Contracts	`$client->usdm()`	Orders, positions, leverage, assign balance, trade history
Coin-M Contracts	`$client->coinM()`	Orders, positions, leverage, risk limit, assign balance
Margin Trading	`$client->margin()`	Orders, borrow history, borrow, payback
Assets & Transfers	`$client->assets()`	Transfers, deposit addresses, deposit/withdraw history

Getting Started: A Quick Example

Installing the package is as simple as running a Composer command:

composer require tigusigalpa/phemex-php

If you are using Laravel, publish the configuration file to customize your settings:

php artisan vendor:publish --provider="Tigusigalpa\Phemex\Laravel\PhemexServiceProvider"

Then, set your environment variables in your .env file:

PHEMEX_API_KEY=your_api_key
PHEMEX_API_SECRET=your_api_secret

Here is how you can fetch the 24-hour ticker for Bitcoin in plain PHP:

use Tigusigalpa\Phemex\PhemexClient;

$client = PhemexClient::create([
    'api_key' => getenv('PHEMEX_API_KEY'),
    'api_secret' => getenv('PHEMEX_API_SECRET'),
]);

$ticker = $client->market()->ticker24h('BTCUSDT');
print_r($ticker->result());

And the equivalent code using the Laravel Facade:

use Tigusigalpa\Phemex\Laravel\Facades\Phemex;

$ticker = Phemex::market()->ticker24h('BTCUSDT');

Creating a spot order is equally straightforward and type-safe:

$order = Phemex::spot()->createOrder([
    'symbol'    => 'BTCUSDT',
    'side'      => 'Buy',
    'ordType'   => 'Limit',
    'orderQty'  => '0.001',
    'priceEp'   => 65000000000,
]);

Exception Handling Done Right

A robust API client must provide clear and actionable error messages. The phemex-php library defines a clear exception hierarchy, allowing you to catch specific errors and respond accordingly:

use Tigusigalpa\Phemex\Exceptions\AuthenticationException;
use Tigusigalpa\Phemex\Exceptions\NotFoundException;
use Tigusigalpa\Phemex\Exceptions\RateLimitException;

try {
    $positions = $client->usdm()->accountPositions();
} catch (AuthenticationException $e) {
    // Handle invalid or missing credentials
} catch (NotFoundException $e) {
    // Handle resource not found
} catch (RateLimitException $e) {
    // Access $e->retryAfter() and $e->remaining()
}

Real-Time Data with WebSockets

While REST APIs are great for executing trades and fetching historical data, real-time trading requires WebSockets. The phemex-php library offers optional WebSocket support via the ratchet/pawl package.

Simply install the dependency:

composer require ratchet/pawl

And you can instantly subscribe to live orderbook updates or trade streams:

use Tigusigalpa\Phemex\WebSocket\Client;

$ws = new Client('wss://vstream.phemex.com/ws');

$ws->connect(
    onMessage: function ($message, $conn) {
        echo $message->getPayload() . PHP_EOL;
    },
    onClose: function ($e) {
        echo 'Connection closed' . PHP_EOL;
    },
);

$ws->subscribe(['orderbook.subscribe', 'trade.subscribe']);

Conclusion

Building a cryptocurrency trading application should be about crafting winning strategies, not battling API intricacies. The phemex-php library abstracts away the complexities of the Phemex REST API, providing a modern, strictly typed, and developer-friendly interface. Whether you are building a simple market data tracker or a sophisticated algorithmic trading bot in Laravel, this package is an invaluable tool in your arsenal.

Check out the repository on GitHub, star the project, and start building your next crypto application today!

GitHub Repository: tigusigalpa/phemex-php

References

Deep Dive into nansen-php: An Elegant PHP Client for the Nansen AI API

Igor — Wed, 15 Jul 2026 15:42:50 +0000

Integrating third-party APIs can often turn into a tedious routine: copy-pasting the same cURL boilerplate, manually decoding JSON responses, and reinventing rate-limit and error-handling logic for every new project. If you are working with cryptocurrency data and leveraging the Nansen AI API, a new library by Igor Sazonov (tigusigalpa) called nansen-php promises to eliminate this headache.

In this article, we will take a comprehensive look at the tigusigalpa/nansen-php repository 1. We will explore its architecture, highlight its key features, and understand why it deserves the attention of PHP developers—especially those working within the Laravel ecosystem.

What is nansen-php?

nansen-php is a framework-agnostic PHP 8.1+ client designed specifically for the Nansen AI API. It provides developers with an elegant, fluent (chainable) interface for making requests, returns strongly typed Data Transfer Objects (DTOs), automatically handles rate limits with built-in retry logic, and offers first-class support for the Laravel framework (versions 10 through 13).

The primary goal of the library is to hide all the HTTP request boilerplate behind an expressive API, making your code read almost like a natural language sentence.

Key Features and Architectural Decisions

After reviewing the library's source code, several strong architectural choices stand out, making it an excellent tool for Nansen AI integration.

1. Expressive Fluent API

Instead of manually constructing arrays of parameters and passing them to an HTTP client, nansen-php employs the Builder pattern. The RequestBuilder class allows you to construct a query step-by-step:

use Tigusigalpa\Nansen\NansenClient;

$client = NansenClient::create(['api_key' => 'YOUR_API_KEY']);

$netflows = $client
    ->smartMoney()
    ->netflows()
    ->chains(['ethereum'])
    ->limit(10)
    ->get();

Every modifier method (chains(), filters(), orderBy(), limit(), offset(), page()) clones the current builder instance and returns a new one. This ensures immutability, allowing you to reuse base queries without unintended side effects.

2. Strict Typing and Data Transfer Objects (DTOs)

One of the biggest pain points when working with external APIs in PHP is dealing with loosely structured, associative arrays. nansen-php solves this by returning typed objects.

All responses inherit from a base Dto class. This means that lists are returned as real collections that you can iterate over, and property access is done via object properties rather than array keys.

An interesting and highly practical architectural decision is that every DTO retains the original, untouched API response in a ->raw property. If Nansen adds a new field to their API response tomorrow, and the library hasn't been updated yet, you can still access that data immediately:

// Accessing new, undocumented fields future-proofs your application
$brandNewField = $netflows->raw['data'][0]['brand_new_field'] ?? null;

This guarantees that you will never lose data due to a lagging library version.

3. Automatic Rate Limit Handling and Retry Logic

Working with robust APIs often involves encountering 429 Too Many Requests errors. The Client class within the Http namespace takes full responsibility for handling these scenarios.

When a 429 status is received, the client automatically extracts the Retry-After, X-RateLimit-Remaining, or RateLimit-Remaining headers. It then pauses script execution for the required duration using usleep() before automatically retrying the request.

For server-side errors (HTTP statuses >= 500), the library implements an exponential backoff algorithm. The number of retry attempts and the base delay are easily configurable.

4. Clear Exception Hierarchy

The library does not simply throw generic exceptions. It provides a structured hierarchy extending from a base ApiException:

RateLimitException: Thrown when the rate limit is exceeded and all retry attempts have been exhausted. It provides useful retryAfter() and remaining() methods.
UnauthorizedException: Thrown for 401 statuses, typically indicating an invalid or expired API key.
NotFoundException: Thrown for 404 statuses when a resource or address cannot be found.

This hierarchy allows developers to easily catch specific errors and handle them gracefully within their applications.

5. HTTP Client Agnosticism (PSR-18)

By default, nansen-php utilizes Guzzle (guzzlehttp/guzzle ). However, the library is fully compliant with the PSR-18 standard. You can inject any other PSR-18 compatible HTTP client by passing it to the constructor or binding it via the Laravel service container. This is particularly useful if you need to use a client with custom middleware, logging, or specific SSL configurations.

6. First-Class Laravel Integration

While the library is framework-agnostic at its core, it provides a seamless developer experience for Laravel users. The package includes an auto-discovered NansenServiceProvider that automatically configures the NansenClient using settings published to config/nansen.php.

It also provides a Nansen facade, enabling you to write highly concise code:

use Tigusigalpa\Nansen\Laravel\Facades\Nansen;

$balances = Nansen::profiler()
    ->addressBalance('0x1234...')
    ->get();

Supported Endpoints

As of version 1.0.0, the library covers the core and most highly requested Nansen AI endpoints:

Category	Available Endpoints
Smart Money	`netflows()`, `holdings()`, `dexTrades()`
Token God Mode	`tokenScreener()`, `flowIntelligence()`, `whoBoughtSold()`
Profiler	`addressBalance()`, `addressDexTrades()`, `addressLabels()`
Portfolio	`defiHoldings()`
Search	`general()`, `entity()`
Historical Data	Access to v1beta1 backtesting endpoints

Because every endpoint shares the same set of modifiers, once you learn how to query one endpoint, you immediately know how to query them all.

Code Quality and Testing

An analysis of the repository reveals a high standard of engineering culture:

PHP 8.1+ Features: The codebase actively utilizes modern PHP features such as readonly properties, match expressions, and strict typing.
Testing: The presence of a tests directory and a phpunit.xml configuration file indicates that the code is covered by tests. According to the README, the test suite runs against a mocked HTTP client, meaning no real API key or network access is required to run them.
Standards: The use of declare(strict_types=1); is consistent across all files.

Conclusion

The tigusigalpa/nansen-php repository is an exemplary model of what a modern PHP API SDK should look like. The author didn't just wrap cURL requests in classes; they created a thoughtful architecture that solves real developer pain points: response typing, rate limit handling, and code readability.

Whether you are building a complex crypto analytics platform on Laravel or a small, standalone PHP script to monitor wallets, this library will save you hours of boilerplate coding and make your codebase cleaner and more reliable.

The repository is MIT licensed and open for contributions. If you are working with the Nansen API, it is definitely worth requiring tigusigalpa/nansen-php in your composer.json.

References

Building Crypto Intelligence with Go: A Deep Dive into the nansen-go Library

Igor — Tue, 14 Jul 2026 19:07:16 +0000

The world of blockchain analytics is vast, complex, and often overwhelming. Developers building crypto applications, trading bots, or analytical dashboards constantly face the challenge of extracting meaningful intelligence from raw onchain data. Enter Nansen AI, a platform renowned for its proprietary data labeling, Smart Money analytics, and comprehensive multi-chain coverage 1. While Nansen provides a powerful API, integrating it cleanly into a Go backend requires a well-designed client. This is where nansen-go shines.

In this review, we will explore nansen-go (available at github.com/tigusigalpa/nansen-go), an elegant, dependency-free Go client for the Nansen AI API. We will examine its design philosophy, key features, and how it simplifies the process of building crypto intelligence applications in Go.

The Philosophy of `nansen-go`: Idiomatic and Unobtrusive

When evaluating a third-party API client, developers often look for a balance between abstraction and control. A good client should handle the boilerplate of HTTP requests, authentication, and error handling without hiding the underlying API or forcing the developer into unnatural patterns. The creator of nansen-go, Igor Sazonov, has clearly embraced this philosophy.

The repository's README states that the library "tries to stay out of your way" 2. This is not just a marketing tagline; it is reflected in the core design choices of the package.

Zero Dependencies

One of the most striking features of nansen-go is its complete lack of third-party dependencies. The entire library is built exclusively on the Go standard library 2.

"Nothing to vendor. The whole thing is built on the standard library. go get it and you're done — no dependency tree to audit." 2

In an era where a simple API client can pull in dozens of transitive dependencies, this is a breath of fresh air. For enterprise applications or security-conscious projects, minimizing the dependency footprint is crucial. It reduces the attack surface, simplifies auditing, and ensures that the client won't conflict with other packages in your project.

Contexts Everywhere

Idiomatic Go code relies heavily on context.Context for managing timeouts, cancellation, and request-scoped values. nansen-go adheres strictly to this convention. Every API call in the library takes a context.Context as its first argument 2. This ensures that developers have fine-grained control over the lifecycle of their requests, making it easy to integrate the client into robust, production-ready systems where timeouts and graceful degradation are essential.

Key Features and Ergonomics

Beyond its architectural philosophy, nansen-go offers a range of features designed to make interacting with the Nansen API as smooth as possible.

Configuration via Functional Options

Instead of relying on massive configuration structs, nansen-go utilizes the functional options pattern for initialization 2. This allows developers to pass only the configuration parameters they need, while sensible defaults handle the rest.

client, err := nansen.New(os.Getenv("NANSEN_API_KEY"),
    nansen.WithTimeout(30*time.Second),
    nansen.WithRetry(3, 500*time.Millisecond, 5*time.Second),
)

Options like WithBaseURL, WithHTTPClient, WithTimeout, and WithRetry provide the flexibility needed to adapt the client to various environments, from local testing to high-throughput production deployments 2.

Concurrency and Safety

Go's concurrency model is one of its strongest selling points, and nansen-go is built to leverage it. The client is designed to be safe for concurrent use across multiple goroutines 2.

"Safe to share. Create one client and hand it to as many goroutines as you like. No locks, no fuss." 2

This means you can instantiate a single nansen.Client at application startup and inject it into your HTTP handlers, background workers, or data pipelines without worrying about race conditions or managing connection pools manually.

Type Safety and Pointer Semantics

The Nansen API expects specific JSON payloads, and nansen-go ensures that your requests are strictly typed. Chains, sort fields, trader types, and labels are defined as real constants in the library 2.

Furthermore, optional request fields are implemented as pointers 2. This is a critical detail in Go, where the zero value of a type (like false for a boolean or 0 for an integer) can sometimes be indistinguishable from an omitted field when marshaling to JSON. By using pointers, nansen-go guarantees that optional fields are only sent when explicitly provided. To alleviate the verbosity of creating pointers to primitive types, the library includes handy helper functions like nansen.StringPtr(), nansen.IntPtr(), and nansen.Float64Ptr() 2.

Advanced Error Handling and Retries

Interacting with any remote API involves handling failures gracefully. Nansen API rate limits and transient network errors are inevitable, and nansen-go provides robust mechanisms to deal with them.

Inspectable Errors

When an API call fails, nansen-go returns an *nansen.APIError. This custom error type provides deep visibility into the failure, exposing the HTTP status code, the error message, the raw response body, and crucial rate-limit headers 2.

Because the library integrates seamlessly with Go's errors.Is and errors.As functions, developers can easily branch their logic based on the specific type of error encountered. The library provides built-in sentinels like nansen.ErrRateLimited, nansen.ErrUnauthorized, and nansen.ErrNotFound for quick checks 2.

Built-in Exponential Backoff

Perhaps the most valuable feature for production use is the built-in retry mechanism. By opting in with nansen.WithRetry(), developers enable automatic retries with exponential backoff 2. The client intelligently handles:

429 Too Many Requests: It pauses execution based on the Retry-After or RateLimit-Reset headers returned by the Nansen API 2.
Transient 5xx Errors: It retries server-side errors that are likely to resolve themselves quickly 2.
Network Flakiness: It attempts to recover from temporary connection drops, provided the request context hasn't expired 2.

Crucially, the retry logic respects the overall timeout budget set by the developer, ensuring that retries never block indefinitely 2.

Mapping the Nansen Ecosystem

The Nansen API is expansive, offering data on Smart Money movements, token flows, portfolio holdings, and historical trends. nansen-go organizes this vast surface area into logical services attached to the main client object 2.

Service Namespace	Description	Example Endpoints
`client.SmartMoney`	Access netflows, holdings, and DEX trades of highly profitable entities.	`/api/v1/smart-money/netflow`
`client.TokenGodMode`	Utilize the token screener, flow intelligence, and buyer/seller analysis.	`/api/v1/token-screener`
`client.Profiler`	Retrieve current balances and DEX trade history for specific addresses.	`/api/v1/profiler/address/current-balance`
`client.Portfolio`	Analyze DeFi holdings and overall portfolio composition.	`/api/v1/portfolio/defi-holdings`
`client.Historical`	Access backtesting endpoints for historical token flows and balances.	`/api/v1beta1/tgm/historical-token-flow-summary`

This modular approach makes the client highly discoverable. Developers can rely on their IDE's autocomplete to explore the available endpoints within a specific domain, rather than sifting through a monolithic list of functions.

Getting Started and Examples

To help developers hit the ground running, the repository includes a dedicated examples directory containing complete, runnable programs 2. These examples cover common use cases such as:

Using the token screener with complex filters and sorting mechanisms.
Profiling specific addresses to retrieve balances and trade history.
Analyzing Smart Money netflows and DEX trades.

Running these examples is as simple as setting the NANSEN_API_KEY environment variable and executing go run 2.

Conclusion

The nansen-go library is a masterclass in designing a Go API client. By adhering strictly to idiomatic Go principles—such as zero dependencies, context propagation, functional options, and strong typing—it provides a robust and developer-friendly interface to the Nansen AI platform.

For developers looking to integrate high-quality onchain analytics into their Go applications, nansen-go abstracts away the complexity of HTTP communication, error handling, and rate limiting, allowing them to focus on what truly matters: building powerful, data-driven crypto products. It is a tool that truly "stays out of your way" while delivering immense value.

References

Exploring coinglass-php: The Ultimate SDK for Coinglass API v4 in PHP and Laravel

Igor — Sun, 12 Jul 2026 22:33:58 +0000

Building cryptocurrency analytics dashboards, liquidation trackers, or monitoring funding rate arbitrage often requires reliable access to high-quality market intelligence data. The Coinglass platform provides one of the most comprehensive APIs for derivatives, ETFs, and on-chain analytics. However, integrating REST APIs and WebSocket streams from scratch can be a real headache for developers: writing endless boilerplate, managing HTTP clients, handling errors, and dealing with rate limits.

Fortunately, a robust solution has emerged for PHP developers. In this article, we will take a deep dive into the coinglass-php package—a modern, framework-agnostic PHP SDK for the Coinglass API v4 that features first-class Laravel integration [1].

What is `coinglass-php`?

The coinglass-php package (developed by Igor Sazonov) serves as a comprehensive wrapper for all six endpoint groups of the Coinglass API v4: Futures, Spot, Options, ETF, On-Chain, and Indicators [1]. Furthermore, it includes a built-in WebSocket client for handling real-time data streams natively.

The package was born out of a developer's frustration with hand-rolling Guzzle calls and juggling raw arrays while building a liquidation dashboard. The result is a strictly typed, PSR-18 compliant client that easily drops into any PHP 8.1+ project, or directly into Laravel (versions 10 through 13) [1].

Key Features of the Package

1. Complete API Coverage

The package supports absolutely every endpoint offered by Coinglass v4. You won't have to manually implement missing methods. Out of the box, you can retrieve open interest history, liquidation data, order books, Bitcoin ETF flows, the Fear & Greed index, and much more [1].

2. Built-in WebSocket Client (No Extra Dependencies)

To work with the Coinglass WebSocket API (which streams liquidations, spot/futures trades, and tickers), you do not need to install heavy third-party libraries like Ratchet or ReactPHP. The client is built natively on top of standard PHP streams (stream_socket_client) and the ext-openssl extension [1]. Subscribing to channels and maintaining the connection—including sending the required "ping" heartbeat every 20 seconds—is handled completely automatically [1].

3. Framework-Agnostic and PSR-18 Swappable

While the package boasts excellent Laravel support, it remains entirely independent of it. It uses Guzzle (^7.4) by default, but thanks to the PSR-18 standard, you can swap it out and inject any HTTP client of your preference [1].

4. Automatic Retry Mechanism

The Coinglass API enforces strict rate limits (HTTP 429 Too Many Requests). coinglass-php handles this elegantly: it automatically retries rate-limited requests using exponential backoff, respectfully honoring the Retry-After header when the server provides one [1].

5. Strict Type Hydration (DTOs)

Say goodbye to unpredictable associative arrays. Every API response is hydrated into a CoinGlassDto object (for a single record) or a CoinGlassCollection (for lists) [1]. You can access fields using whatever syntax feels most natural: property syntax ($dto->openInterestUsd), array syntax ($dto['openInterestUsd']), or getter methods ($dto->get('openInterestUsd')). If you ever need the untouched raw payload, it is always available via $dto->raw or $dto->toArray() [1].

6. Clear Exception Hierarchy

Instead of throwing a single catch-all Exception, the package provides a clear and purposeful exception hierarchy: UnauthorizedException, NotFoundException, RateLimitException, and a generic ApiException for all other API-related errors [1]. This makes writing fault-tolerant code much simpler.

Laravel Integration: Ready Out of the Box

For users of Laravel (versions 10, 11, 12, and 13), the package provides maximum convenience. After installing via Composer (composer require tigusigalpa/coinglass-php), you can publish the configuration file:

php artisan vendor:publish --tag=coinglass-config

Configuration is then easily managed through your .env file:

COINGLASS_API_KEY=your-api-key
COINGLASS_BASE_URL=https://open-api-v4.coinglass.com
COINGLASS_TIMEOUT=15
COINGLASS_RETRY_ATTEMPTS=3
COINGLASS_RETRY_DELAY=1

You can leverage Dependency Injection to receive the CoinGlassClient in your controllers, or utilize the elegant CoinGlass facade:

use Tigusigalpa\CoinGlass\Laravel\Facades\CoinGlass;

// Fetching BTC open interest history for the last 30 days
$oi = CoinGlass::futures()->openInterestOhlcHistory('BTC', '1d', 30);

Practical Usage Examples

The client's API is logically divided into endpoint groups. Here are a few examples demonstrating how effortless it is to retrieve the data you need:

Working with Futures:

$client = CoinGlassClient::make('YOUR_API_KEY');

// Funding rate exchange list
$funding = $client->futures()->fundingRateExchangeList('BTC');

// Liquidation history
$liq = $client->futures()->liquidationHistory('BTC', 'BTCUSDT', '1h');

Fetching ETF Data:

// Bitcoin ETF flows over the last 24 weeks
$flows = $client->etf()->bitcoinFlowHistory('1w', 24);

Real-time WebSocket Streaming:

use Tigusigalpa\CoinGlass\WebSocket\Channels;
use Tigusigalpa\CoinGlass\WebSocket\Message;

$stream = $client->websocket()->connect();

$stream->subscribe(
    Channels::liquidationOrders(),
    Channels::futuresTicker('Binance', 'BTCUSDT'),
);

$stream->listen(function (Message $message) {
    if ($message->channel === Channels::liquidationOrders()) {
        foreach ($message->collection() as $order) {
            echo "{$order->exchange} {$order->symbol} liquidated \${$order->volume_usd}\n";
        }
    }
});

The listen() method blocks execution forever, making it a perfect fit for long-running CLI workers or queued Laravel jobs [1].

Conclusion

The coinglass-php package is a prime example of what a modern PHP API client should look like. It abstracts away all the tedious boilerplate related to HTTP requests, rate limiting, and WebSocket connections, providing developers with a clean, typed, and predictable interface.

Whether you are building a complex algorithmic trading system in vanilla PHP or developing a crypto analytics portal in Laravel 11, this package will save you hours—if not days—of development time.

The code quality is backed by solid test coverage (using PHPUnit and Orchestra Testbench for Laravel) and leverages the modern features of PHP 8.1+ [2]. If your project involves crypto market intelligence, coinglass-php absolutely deserves a spot in your composer.json.

References

[1] tigusigalpa/coinglass-php GitHub Repository

[2] tigusigalpa/coinglass-php Packagist Page

Building a Zero-Dependency Go Client for the Coinglass Crypto Data API

Igor — Sun, 12 Jul 2026 18:00:51 +0000

If you are building cryptocurrency trading algorithms, liquidation dashboards, or funding rate arbitrage bots, you already know that data is everything. In the crypto derivatives space, Coinglass has established itself as the premier platform for market data. With the release of their unified API v4, they opened up institutional-grade access to open interest, funding rates, liquidations, and order book heatmaps across all major exchanges.

However, when I started building my own tooling in Go to consume this data, I noticed a gap. I wanted a strongly typed, concurrent-safe client that didn't drag a massive tree of third-party dependencies into my go.mod file.

To solve this, I built coinglass-go — a small, idiomatic, and dependency-free Go SDK for the Coinglass API v4. In this article, I want to share the design decisions behind the library, how it handles rate limiting gracefully, and how you can use it to power your own crypto analytics tools.

Why Build Another API Client?

When integrating with REST APIs in Go, developers generally have two choices: use an auto-generated client (like OpenAPI/Swagger) or write a custom wrapper. Auto-generated clients are great for API coverage, but they often result in unidiomatic Go code, weird pointer types, and bloated dependencies.

For coinglass-go, the goals were strict:

Zero Dependencies: The library leans entirely on the Go standard library (net/http, encoding/json, context, time ). Adding it to your project costs nothing in terms of binary bloat.
Idiomatic Design: It uses the functional options pattern for configuration, requires context.Context for every network call, and organizes endpoints into logical sub-services (Futures, Spot, Options, ETF, Indicators).
Resilience: Crypto APIs are notorious for strict rate limits. The client needed built-in exponential backoff that automatically honors Retry-After headers.

Designing the Client Architecture

The entry point to the SDK is the Client struct, which holds the HTTP configuration and exposes the API resource groups as fields. This pattern is heavily inspired by Google's go-github library.

type Client struct {
    // Internal configuration
    apiKey      string
    baseURL     string
    httpClient  *http.Client
    maxAttempts int
    baseDelay   time.Duration

    // Exposed Services
    Futures    *FuturesService
    Spot       *SpotService
    Options    *OptionsService
    ETF        *ETFService
    Indicators *IndicatorsService
}

Configuration is handled via the functional options pattern. This makes the NewClient constructor clean while allowing advanced users to inject custom http.Transport layers, adjust timeouts, or enable retries.

import (
    "time"
    coinglass "github.com/tigusigalpa/coinglass-go"
 )

client := coinglass.NewClient("YOUR_API_KEY",
    coinglass.WithTimeout(15*time.Second),
    coinglass.WithRetry(3, time.Second), // 3 attempts, 1s initial backoff
)

Handling Rate Limits with Grace

The Coinglass API enforces rate limits based on your subscription tier (e.g., 30 requests/min for Hobbyist, up to 1200 for Professional). Handling HTTP 429 Too Many Requests is mandatory for any serious application.

Instead of forcing the user to implement their own retry loops, coinglass-go handles this internally. When WithRetry() is enabled, the client intercepts 429 responses. It first checks if the API provided a Retry-After header. If so, it sleeps for that duration. If not, it falls back to an exponential backoff strategy (1s, 2s, 4s...).

Crucially, because every method takes a context.Context, the retry sleep loop is fully cancellable. If your application is shutting down, or a parent timeout is reached, the select block immediately unblocks and returns ctx.Err().

timer := time.NewTimer(delay)
select {
case <-ctx.Done():
    timer.Stop()
    return ctx.Err() // Abort retry if context is cancelled
case <-timer.C:
    // Proceed with next attempt
}

Exploring the Data: Open Interest and Funding Rates

Let's look at how easy it is to pull actionable market data. Suppose you are building a dashboard that tracks the Open Interest (OI) and Funding Rates for Bitcoin across all exchanges.

Because the SDK uses strong typing, optional query parameters are passed as pointers. To make this ergonomic, the library includes helpers like coinglass.IntPtr().

ctx := context.Background()

// Fetch BTC open interest history (last 30 days, daily)
oi, err := client.Futures.OpenInterestHistory(ctx, &coinglass.OIHistoryParams{
    Symbol:   "BTC",
    Interval: "1d",
    Limit:    coinglass.IntPtr(30),
})
if err != nil {
    log.Fatal(err)
}

for _, point := range oi {
    fmt.Printf("OI: %.2f USD at timestamp %d\n", point.OpenInterestUsd, point.Timestamp)
}

If you want to hunt for arbitrage opportunities, you can pull the funding rate disparities across exchanges in a single call:

arb, err := client.Futures.FundingRateArbitrage(ctx, &coinglass.FundingRateArbitrageParams{
    Symbol: coinglass.StringPtr("BTC"),
})

for _, item := range arb {
    fmt.Printf("Exchange: %s, Spread: %.4f\n", item.Exchange, item.Spread)
}

Built for Concurrency

Go shines in concurrent workloads, and fetching data for dozens of trading pairs sequentially is a waste of time. The coinglass.Client is completely thread-safe. You can safely share a single instance across hundreds of goroutines.

Here is an example of fetching open interest for multiple symbols concurrently using a sync.WaitGroup:

symbols := []string{"BTC", "ETH", "SOL", "DOGE", "XRP"}
var wg sync.WaitGroup

for _, symbol := range symbols {
    wg.Add(1)
    go func(sym string) {
        defer wg.Done()

        // Safe concurrent access
        data, err := client.Futures.OpenInterestHistory(ctx, &coinglass.OIHistoryParams{
            Symbol:   sym,
            Interval: "1h",
            Limit:    coinglass.IntPtr(24),
        })

        if err != nil {
            log.Printf("Failed to fetch %s: %v", sym, err)
            return
        }
        log.Printf("Fetched %d hours of OI for %s", len(data), sym)
    }(symbol)
}

wg.Wait()

Error Handling

When dealing with financial APIs, generic errors aren't enough. You need to know exactly why a request failed. The SDK wraps all non-2xx responses in a custom *coinglass.APIError struct, which contains the HTTP status code, the Coinglass-specific error code, and the raw JSON body.

It also provides sentinel errors that work seamlessly with Go 1.13+ errors.Is and errors.As:

import "errors"

_, err := client.Futures.SupportedCoins(ctx)
if err != nil {
    switch {
    case errors.Is(err, coinglass.ErrUnauthorized):
        log.Fatal("Invalid API key! Please check your COINGLASS_API_KEY.")
    case errors.Is(err, coinglass.ErrRateLimited):
        log.Fatal("Rate limit exceeded and retries exhausted.")
    default:
        var apiErr *coinglass.APIError
        if errors.As(err, &apiErr) {
            log.Fatalf("API rejected request: Code %s, Message: %s", apiErr.Code, apiErr.Message)
        }
    }
}

Beyond Futures: Spot, Options, and ETFs

While Coinglass is famous for derivatives data, API v4 unified their offering. The coinglass-go SDK provides full coverage for these endpoints as well.

You can track Bitcoin ETF inflows:

flows, _ := client.ETF.BitcoinFlowHistory(ctx, &coinglass.ETFFlowParams{
    Interval: "1w",
})

Or pull the current Crypto Fear & Greed Index:

fg, _ := client.Indicators.FearGreedHistory(ctx, &coinglass.FearGreedParams{
    Limit: coinglass.IntPtr(1),
})
fmt.Printf("Market Sentiment: %s\n", fg[0].Classification)

Conclusion

Building coinglass-go was an exercise in keeping things simple. By avoiding third-party dependencies and leaning into Go's standard library, the result is a fast, resilient, and predictable SDK.

If you are building crypto data pipelines, algorithmic trading bots, or market research tools in Go, give it a try. The source code is fully open-source under the MIT license.

GitHub Repository: tigusigalpa/coinglass-go

Contributions, issues, and pull requests are always welcome. Happy coding!

Supercharge Your Crypto and Stock Analytics with lunarcrush-go

Igor — Thu, 09 Jul 2026 06:00:24 +0000

Are you building a trading dashboard, a market sentiment tracker, or a financial data pipeline in Go? If so, you know that gathering reliable social intelligence and market data is often a complex, messy process. You have to juggle raw HTTP requests, decode deeply nested JSON payloads, and manually handle rate limits. But what if you could access a wealth of crypto and stock social intelligence idiomatically, right where your Go code lives?

Enter lunarcrush-go, a powerful, zero-dependency SDK designed to seamlessly integrate the LunarCrush API v4 into your Golang applications.

In this article, we will explore why lunarcrush-go is the ultimate tool for developers looking to tap into social and market intelligence, how to get started in under 60 seconds, and why its zero-dependency architecture makes it a robust choice for production workloads.

Why LunarCrush?

Before diving into the SDK, it is worth understanding what LunarCrush brings to the table. LunarCrush goes beyond traditional price charts. It measures what the internet is actually saying about Bitcoin, Ethereum, Tesla, and thousands of other assets. By analyzing social buzz, creator impact, and overall market sentiment across various platforms, LunarCrush provides a holistic view of the market 1.

Whether you want to know the Galaxy Score of a specific coin, track the hourly social time-series of a stock, or get AI-generated insights on a trending topic, LunarCrush has you covered.

Introducing lunarcrush-go

The lunarcrush-go library was built with one primary goal: to provide clean, typed, and production-ready access to every LunarCrush endpoint without pulling in a single third-party dependency. It speaks Go natively, meaning you do not have to wrestle with raw JSON or hand-roll your own retry loops.

Key Features

Here is what makes lunarcrush-go stand out:

Complete API Coverage: The SDK supports every LunarCrush endpoint, including Coins, Stocks, Topics, Categories, Creators, Posts, Searches, AI summaries, and System changes.
Truly Zero Dependencies: It relies entirely on the Go standard library (net/http, encoding/json, context, time ). No go.sum bloat, no dependency tree drama.
Functional Options: Configure the client the idiomatic Go way, mixing and matching only what you need.
Context-Aware & Concurrent: Every method accepts context.Context, and the client is completely safe for use across multiple goroutines.
Built-In Resilience: Automatic retry with exponential backoff on HTTP 429 errors, strictly respecting the Retry-After header when LunarCrush tells you to wait.
Friendly Error Handling: Sentinel errors for common HTTP statuses (401, 404, and 429), plus detailed APIError values for everything else.

Getting Started in 60 Seconds

Getting up and running with lunarcrush-go is incredibly fast. First, drop it into your project with a single command:

go get github.com/tigusigalpa/lunarcrush-go

Note: Requires Go 1.21 or newer.

Next, here is a tiny, complete program you can run right away to fetch the 24-hour social summary for Bitcoin and the top 10 coins by Galaxy Score:

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    lunarcrush "github.com/tigusigalpa/lunarcrush-go"
)

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

    // Initialize the client with your API key and custom options
    client := lunarcrush.NewClient("YOUR_API_KEY",
        lunarcrush.WithTimeout(15*time.Second),
        lunarcrush.WithRetry(3, time.Second), // 3 attempts, 1s initial backoff
    )

    // 1. Fetch 24-hour social summary for Bitcoin
    topic, err := client.Topics.Get(ctx, "bitcoin")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Bitcoin interactions (24h): %.0f\n", topic.Data.Interactions24h)

    // 2. Fetch Top 10 coins by Galaxy Score
    sort := "galaxy_score"
    limit := 10
    coins, err := client.Coins.List(ctx, &lunarcrush.CoinsListParams{
        Sort:  &sort,
        Limit: &limit,
        Desc:  ptr(true),
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("\nTop 10 Coins by Galaxy Score:")
    for _, coin := range coins.Data {
        fmt.Printf("%s — Galaxy Score: %.1f\n", coin.Symbol, coin.GalaxyScore)
    }
}

func ptr[T any](v T) *T { return &v }

Compile and run it, and you are instantly talking to LunarCrush from Go!

Built for Production

When building production systems, you need reliability. lunarcrush-go is designed with robust error handling and concurrency in mind.

Contexts and Concurrency

All methods are context-first. Whether you pass context.Background(), context.WithTimeout(), or context.WithCancel(), the SDK adapts to your flow. Furthermore, the client is safe to share across goroutines. You can fetch data for multiple coins in parallel without the overhead of creating new clients.

Rate Limits and Retry Behavior

LunarCrush rate limits depend on your specific plan 1. Hitting a 429 Too Many Requests is not a panic moment with lunarcrush-go. By enabling retries during client configuration, the SDK will automatically back off, doubling the wait time on each attempt, and honoring the Retry-After header.

client := lunarcrush.NewClient("YOUR_API_KEY",
    lunarcrush.WithRetry(3, time.Second), 
)

Error Handling Done Right

Every non-2xx response is returned as a detailed *lunarcrush.APIError. For common statuses, you can easily use errors.Is with sentinel errors like lunarcrush.ErrUnauthorized, lunarcrush.ErrNotFound, or lunarcrush.ErrRateLimited. The raw response body is also preserved, making debugging weird API responses much easier.

Are you a PHP Developer? We have you covered!

If your tech stack leans towards PHP, you do not have to miss out on this streamlined experience. We have also built lunarcrush-php, a modern, framework-agnostic SDK for PHP 8.1+ 2.

Just like its Go counterpart, lunarcrush-php wraps every public endpoint behind a fluent, strongly-typed interface. It features readonly DTOs, typed collections, automatic rate-limit retries, and even first-class Laravel 10/11 integration out of the box.

Whether you are writing Go or PHP, integrating LunarCrush has never been more elegant.

Conclusion

Building robust financial and social intelligence applications requires tools that are reliable, fast, and easy to use. lunarcrush-go delivers on all fronts by providing a zero-dependency, context-aware, and highly resilient SDK for the LunarCrush API.

Ready to supercharge your analytics? Check out the lunarcrush-go repository on GitHub, drop a star, and start building! If you find a bug or have an idea for a better example, pull requests are always welcome.

Happy building! 🚀

References

telegram-wallet-go: The Lightweight Go SDK for Accepting Crypto Payments in Telegram

Igor — Thu, 16 Apr 2026 09:28:24 +0000

Telegram has evolved far beyond a simple messaging application. With its massive user base and deep integration with the TON blockchain ecosystem, it has become a powerful platform for commerce, gaming, and decentralized applications. For developers building Telegram bots and Mini Apps, the ability to monetize by accepting cryptocurrency payments directly within the chat interface is a game-changer.

The official Telegram Wallet Pay API enables merchants to accept TON, USDT, BTC, and NOT from users seamlessly, without redirecting them outside of Telegram [1]. However, integrating a raw REST API involves handling authentication, constructing request payloads, verifying cryptographic webhook signatures, and mapping HTTP status codes to meaningful errors. Doing this from scratch in Go can be tedious and error-prone.

Enter telegram-wallet-go. Created by Igor Sazonov, this open-source Go SDK wraps the Wallet Pay API in a clean, idiomatic, and lightweight interface. It provides everything you need to start accepting crypto payments in your Go applications, with zero external dependencies for the core client and built-in middleware for popular web frameworks. In this article, we will explore the features, architecture, and usage of this excellent library.

Why Choose telegram-wallet-go?

When building backend services in Go, developers value simplicity, performance, and strong typing. The telegram-wallet-go library aligns perfectly with these principles. Its key design goals include:

Zero Core Dependencies: The core client relies entirely on the Go standard library (net/http, crypto/hmac, encoding/json, etc.), keeping your go.mod clean and reducing the risk of supply chain vulnerabilities.
Idiomatic Go Design: It uses the functional options pattern for configuration, context-aware requests (context.Context), and strong typing for all API requests and responses.
Framework Integrations: While the core is dependency-free, it provides optional middleware for net/http, Gin, and Echo to handle webhook signature verification effortlessly.
Security by Default: Webhook signature verification using HMAC-SHA256 is built-in, ensuring that you only process legitimate payment events from Wallet Pay.
Comprehensive Error Handling: It maps HTTP status codes to specific error types (e.g., AuthError, RateLimitError), making it easy to handle different failure scenarios programmatically.

Getting Started

Installation is as simple as running a go get command. The library requires Go 1.21 or higher.

go get github.com/tigusigalpa/telegram-wallet-go

Initializing the Client

The library uses the functional options pattern, allowing you to configure the client cleanly. You only need your Store API Key, which you can obtain from the @WalletPay_Support_Bot on Telegram.

package main

import (
    "net/http"
    "time"

    "github.com/tigusigalpa/telegram-wallet-go"
)

func main() {
    // Basic initialization
    client := walletpay.NewClient("YOUR_STORE_API_KEY")

    // Advanced initialization with custom options
    customClient := walletpay.NewClient(
        "YOUR_STORE_API_KEY",
        walletpay.WithBaseURL("https://pay.wallet.tg"),
        walletpay.WithTimeout(60 * time.Second),
        walletpay.WithHTTPClient(&http.Client{
            Timeout: 90 * time.Second,
            Transport: &http.Transport{
                MaxIdleConns:        100,
                MaxIdleConnsPerHost: 10,
            },
        }),
    )
}

Creating a Payment Order

Creating an order is straightforward thanks to the strongly typed CreateOrderRequest struct. This ensures you provide all required fields correctly.

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/tigusigalpa/telegram-wallet-go"
)

func main() {
    client := walletpay.NewClient("YOUR_STORE_API_KEY")

    order, err := client.CreateOrder(context.Background(), walletpay.CreateOrderRequest{
        Amount: walletpay.MoneyAmount{
            CurrencyCode: "USD",
            Amount:       "9.99",
        },
        Description:            "Premium subscription for 1 month",
        ExternalID:             "ORDER-12345",  // Your unique order ID for idempotency
        TimeoutSeconds:         3600,           // 1 hour to pay
        CustomerTelegramUserID: 123456789,      // Restrict payment to this user
        AutoConversionCurrency: "USDT",         // Automatically convert received funds to USDT
        ReturnURL:              "https://t.me/YourBot/YourApp",
        CustomData:             `{"user_id":42}`, // Metadata returned in webhooks
    })

    if err != nil {
        log.Fatal(err)
    }

    // The DirectPayLink is what you send to the user
    fmt.Println("Payment URL:", order.DirectPayLink)
}

The DirectPayLink can be used as an Inline Button URL in a bot message or opened via Telegram.WebApp.openTelegramLink(url) in a Mini App [1].

Handling Webhooks Securely

When a payment succeeds or fails, Wallet Pay sends a webhook to your server. Verifying the HMAC-SHA256 signature of these webhooks is critical to prevent spoofing. telegram-wallet-go makes this incredibly easy by providing ready-to-use middleware.

Using Standard `net/http`

package main

import (
    "log"
    "net/http"

    "github.com/tigusigalpa/telegram-wallet-go"
    "github.com/tigusigalpa/telegram-wallet-go/middleware"
)

func main() {
    client := walletpay.NewClient("YOUR_STORE_API_KEY")

    http.HandleFunc("/webhook/walletpay", middleware.WalletPayWebhookHandler(
        client,
        func(w http.ResponseWriter, r *http.Request, events []walletpay.WebhookEvent) {
            for _, event := range events {
                if event.Type == walletpay.WebhookEventOrderPaid {
                    log.Printf("Order %d paid: %s", event.Payload.ID, event.Payload.ExternalID)
                    // Fulfill the order (e.g., grant premium access)
                }
            }
            // Always acknowledge receipt
            w.WriteHeader(http.StatusOK)
            w.Write([]byte("OK"))
        },
    ))

    log.Fatal(http.ListenAndServe(":8080", nil))
}

Using Gin Framework

If you use Gin, you can leverage the specific middleware by building with the gin tag (go build -tags gin).

import (
    "github.com/gin-gonic/gin"
    "github.com/tigusigalpa/telegram-wallet-go"
    "github.com/tigusigalpa/telegram-wallet-go/middleware"
)

func main() {
    router := gin.Default()
    client := walletpay.NewClient("YOUR_API_KEY")

    router.POST("/webhook/walletpay", middleware.GinWebhookMiddleware(client), func(c *gin.Context) {
        // Retrieve parsed events from the context
        events, _ := c.Get("walletpay_events")

        for _, event := range events.([]walletpay.WebhookEvent) {
            if event.Type == walletpay.WebhookEventOrderPaid {
                // Handle successful payment
            }
        }

        c.String(200, "OK")
    })

    router.Run(":8080")
}

Similar middleware is available for the Echo framework as well.

Best Practices for Production

When implementing Wallet Pay in production, keep these best practices in mind:

Idempotency: Wallet Pay may send the same webhook multiple times due to network retries. Always use the EventID from the WebhookEvent to ensure you process each event only once.
External ID: Use the ExternalID field when creating an order as your idempotency key. If you attempt to create an order with an existing ExternalID, the API will return the existing order instead of creating a duplicate.
Acknowledge Quickly: Always return an HTTP 200 OK status as quickly as possible in your webhook handler. Perform heavy processing (like database updates or sending emails) asynchronously.

Conclusion

The telegram-wallet-go library is a stellar example of how an SDK should be written in Go. It is lightweight, secure, idiomatic, and provides exactly what developers need without unnecessary bloat. Whether you are building a simple storefront bot or a complex Telegram Mini App, this library will save you hours of boilerplate code and debugging.

You can check out the source code, contribute, or star the repository on GitHub: tigusigalpa/telegram-wallet-go.

Happy coding, and enjoy building the next generation of crypto-enabled Telegram applications!

References

[1] Wallet Pay API Documentation

DEV Community: Igor

Building Reliable Crypto Alerting Systems in Go: A Deep Dive into the whale-alert-go SDK

Core Philosophy: Idiomatic Go

REST API: Clean and Resilient

WebSocket Alerts: Built to Survive

Safe Pagination and Error Handling

Conclusion

References

Track Blockchain Whale Activity in PHP with whale-alert-php

Why a dedicated PHP SDK matters

Install it with Composer

Start with the REST API

Make pagination a safe default

Stream real-time alerts with WebSockets

Handle failures intentionally

A natural fit for Laravel

Build the blockchain feature, not the plumbing

References

Supercharge Your Algorithmic Trading with CoinQuant PHP: The Ultimate SDK for Laravel and PHP 8.1+

Why Choose CoinQuant PHP?

1. Built for Modern PHP

2. First-Class Laravel Integration

3. Comprehensive API Coverage

4. Effortless Streaming via Generators

5. Simplified Backtesting

6. Actionable Exceptions

Getting Started: From Zero to Backtest

Installation

Configuration

The Workflow: Idea to Metrics

Advanced Usage: Streaming and Customization

Real-Time Streaming

Custom HTTP Clients

Conclusion

Build AI-Powered Trading Strategies in Go with CoinQuant-Go

The Problem with API Boilerplate

Why Choose CoinQuant-Go?

1. Idiomatic Go Design

2. Comprehensive API Coverage

3. Robust SSE Streaming

4. Seamless Backtesting Workflows

5. Schema-Only Materialization

6. Actionable Error Handling

Getting Started with CoinQuant-Go

Installation

Initializing the Client

Streaming an AI Prompt

The Complete Workflow: From Idea to Metrics

Conclusion

Building High-Performance Crypto Trading Bots with Go: Meet phemex-go

Why Choose phemex-go?

Getting Started

Installation

Core Architecture

Exploring the REST API

Fetching Public Market Data

Placing a Spot Trade

Streaming Real-Time Data with WebSockets

Smart Error Handling and Retries

Conclusion

Stop Wrestling with cURL: The Modern PHP Client for Phemex Crypto Trading

The Challenge of Crypto API Integration

Why Choose phemex-php?

1. Strictly Typed and Future-Proof

2. Framework-Agnostic with First-Class Laravel Support

3. Automatic HMAC Signing and Rate Limit Handling

4. Bring Your Own HTTP Client

5. Comprehensive Endpoint Coverage

Getting Started: A Quick Example

Exception Handling Done Right

Real-Time Data with WebSockets

Conclusion

References

Deep Dive into nansen-php: An Elegant PHP Client for the Nansen AI API

What is nansen-php?

Key Features and Architectural Decisions

1. Expressive Fluent API

2. Strict Typing and Data Transfer Objects (DTOs)

3. Automatic Rate Limit Handling and Retry Logic

4. Clear Exception Hierarchy

Why Choose `phemex-go`?

The Philosophy of `nansen-go`: Idiomatic and Unobtrusive

What is `coinglass-php`?

Using Standard `net/http`