# Crypto Carry Scanner (`gladsome_mailbox/crypto-carry-scanner`) Actor

Compare read-only USDT perpetual funding snapshots across Binance, Bybit, and Gate. Returns one structured result with explicit cost assumptions, venue failures, and risk limitations.

- **URL**: https://apify.com/gladsome\_mailbox/crypto-carry-scanner.md
- **Developed by:** [caitlyn](https://apify.com/gladsome_mailbox) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.15 / crypto carry comparison result

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Crypto Carry Scanner

Compare current USDT perpetual funding snapshots across Binance USD-M, Bybit Linear, Gate USDT Futures, and Bitget USDT Futures. The scanner normalizes each venue's reported funding interval, pairs only exact matching base symbols, applies your per-leg volume screen, subtracts your explicit annualized cost assumption, and ranks the remaining momentary estimates.

This is read-only informational research tooling. It does not recommend, prepare, route, or place trades.

### What you get

Each successful run writes one dataset item containing:

- requested, successful, and failed venue status;
- warnings for malformed records, fallback interval use, pagination limits, or partial venue failure;
- the number of usable market records and matching opportunities;
- up to 50 ranked opportunity rows;
- both legs' symbols, venues, raw funding rates, funding intervals, annualized rates, reported 24-hour quote volume, and next funding timestamps when available;
- gross APR arithmetic, your annualized cost deduction, and the resulting net APR estimate;
- explicit flags confirming that the result is informational only and that no account, credentials, or orders were used.

A valid scan may return zero opportunities when at least two venues succeeded but no exact base pair passed the volume filter.

### Input

All fields are optional and have bounded defaults:

- `venues`: two to four values from `binance`, `bybit`, `gate`, and `bitget`; default is all four.
- `minVolumeUsd`: minimum reported 24-hour quote turnover for each leg, from 0 to US$1 trillion; default US$10 million.
- `annualizedCostPct`: annualized cost percentage subtracted from every gross spread, from 0% to 100%; default 3.8933%.
- `maxResults`: 1–50 nested rows; default 20.
- `timeoutSeconds`: 1–15 seconds per request; default 10.
- `retries`: 0–2 retries after the first request; default 1.

Do not submit a URL, API key, secret, file, account, wallet, position, order, prompt, or customer identifier. Those fields are not accepted.

### Data behavior

The scanner sends credential-free HTTPS GET requests only to fixed public market-data endpoints on:

- `fapi.binance.com`
- `api.bybit.com`
- `api.gateio.ws`
- `api.bitget.com`

Any failed venue is recorded as a warning when at least two other venues remain usable. Fewer than two usable venues ends the run without a result. Binance and Bybit may block requests from some Apify Cloud regions; Gate and Bitget provide additional fixed public sources, but no venue is guaranteed reachable from every region. Each response is capped at 25 MiB, and all response chunks across pages and retries share a 40 MiB download cap. An 85-second scan-work budget operates within the 90-second run limit. Exceeding any limit fails closed.

The result is one dataset item with at most 50 opportunity rows. Standby mode is not used, memory is capped at 256 MiB, and the Actor requires only limited input, fixed-host network, dataset, and billing permissions.

### Pricing

The paid price is US$0.15 per valid result. In pay-per-event mode, the single dataset write and the single `crypto-carry-scan-result` event are combined. Invalid input, fewer than two usable venues, result-generation failure, and dataset-write failure do not produce a paid result.

If the run is offered in free mode, the same result is written without a paid event. The dataset result itself contains no payment, price, or charge metadata.

### Privacy

Input is limited to public venue selections and bounded numeric assumptions. No credentials, account identifiers, positions, orders, files, or customer text are requested or used.

The selected venues and network providers can observe ordinary request metadata such as IP address, time, and user-agent. Apify can retain run input, logs, and dataset output under its plan and platform policies. No no-store behavior is promised.

### Limitations and risk

The scanner uses current reported funding and turnover, not executable order-book depth. Annualizing a snapshot does not predict future funding or realized return. Funding can change or reverse before settlement, and venue settlement times or contract terms can differ.

The calculation omits or simplifies basis divergence, fee tiers, maker rebates, slippage, legging, margin, liquidation, collateral impairment, borrow, transfer delay and cost, outages, tax, jurisdiction, and venue insolvency. Losses can exceed the apparent funding income.

This output is not financial, investment, legal, or tax advice, is not a suitability assessment or trade recommendation, and does not guarantee profit or any return. Verify current markets, rules, depth, costs, collateral, and local restrictions independently before making a decision.

# Actor input Schema

## `venues` (type: `array`):

Select at least two fixed public market-data venues. Some venues may be region-blocked from a given run location.

## `minVolumeUsd` (type: `number`):

Coarse liquidity screen only; not executable depth.

## `annualizedCostPct` (type: `number`):

Explicit annualized execution-cost deduction applied to every gross spread. This is an assumption, not a quoted fee.

## `maxResults` (type: `integer`):

Rows nested inside the single dataset result item. Hard-capped at 50.

## `timeoutSeconds` (type: `number`):

Bounded per-request timeout; the Actor also keeps an 85-second internal work budget for a 90-second run cap assumption.

## `retries` (type: `integer`):

Conservative retry count for transient public endpoint failures.

## Actor input object example

```json
{
  "venues": [
    "binance",
    "bybit",
    "gate",
    "bitget"
  ],
  "minVolumeUsd": 10000000,
  "annualizedCostPct": 3.8933,
  "maxResults": 20,
  "timeoutSeconds": 10,
  "retries": 1
}
```

# Actor output Schema

## `results` (type: `string`):

Default dataset item with venue status, assumptions, ranked momentary estimates, and risk limitations.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "venues": [
        "binance",
        "bybit",
        "gate",
        "bitget"
    ],
    "minVolumeUsd": 10000000,
    "annualizedCostPct": 3.8933,
    "maxResults": 20,
    "timeoutSeconds": 10,
    "retries": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("gladsome_mailbox/crypto-carry-scanner").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "venues": [
        "binance",
        "bybit",
        "gate",
        "bitget",
    ],
    "minVolumeUsd": 10000000,
    "annualizedCostPct": 3.8933,
    "maxResults": 20,
    "timeoutSeconds": 10,
    "retries": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("gladsome_mailbox/crypto-carry-scanner").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "venues": [
    "binance",
    "bybit",
    "gate",
    "bitget"
  ],
  "minVolumeUsd": 10000000,
  "annualizedCostPct": 3.8933,
  "maxResults": 20,
  "timeoutSeconds": 10,
  "retries": 1
}' |
apify call gladsome_mailbox/crypto-carry-scanner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gladsome_mailbox/crypto-carry-scanner"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/JCsa4wtBViSW6qjfo/builds/QpJbyjVZFKYUZ7rBv/openapi.json