AI-native runtime for Coins.ph trading strategies
Author in Cursor, Claude Code or any AI IDE. Deploy from GitHub into a managed cloud runtime with first-class MCP control, logs and region selection.
Section 01 · At a glance
At a glance
- Venue
- Coins.ph
- Venue type
- Crypto exchange (BSP-regulated, Philippines)
- Asset class
- Crypto with PHP fiat quote
- Supported products
- Spot trading on PHP-quote pairs (BTCPHP, ETHPHP, USDCPHP and others), USDT and USDC stablecoin pairs, master and virtual sub-account hierarchies, TradeDesk OTC desk with INSTANT, MANUAL_DEFER and AUTO_DEFER settlement modes
- Runtime model
- Containerised strategy runtime
- Deployment source
- GitHub
- Languages
- Any language that runs in a container
- Common integrations
- Native Coins.ph REST and WebSocket, CCXT, custom connectors
- AI workflow integration
- MCP control surface for Cursor, Claude Code, GitHub Copilot and CLI agents
- TradingHost role
- Runtime, deployment, logs, health checks, region selection, MCP control
- Coins.ph role
- Exchange account, API access, market access, execution venue
- Affiliation
- TradingHost is independent and is not affiliated with Coins.ph
Section 02 · What Coins.ph offers
What Coins.ph offers
Coins.ph offers spot trading on PHP-quote pairs (BTCPHP, ETHPHP, USDCPHP and others) and USDT/USDC stablecoin pairs through REST and WebSocket APIs. Strategies authenticate with an `X-COINS-APIKEY` header scoped to route categories, and the venue exposes master and virtual sub-accounts for per-strategy isolation. Endpoint specifics change over time. The shape is durable; the precise rate-limit weights, symbol lists and fiat-rail limits live in Coins.ph's docs.
Markets and strategy patterns
- PHP-quote spot strategies (BTCPHP, ETHPHP, USDCPHP)
- Stablecoin-fiat arbitrage between USDT/USDC and PHP
- INSTAPAY-funded intraday strategies
- TradeDesk OTC settlement (INSTANT, MANUAL_DEFER, AUTO_DEFER)
- Master and virtual sub-account isolated multi-strategy deployments
- WebSocket User Data Stream consumers with 5-minute keep-alive
- Filipino-peso-quoted basis vs USDT carry strategies
API surface
- Product surfaces
- Spot trading on PHP-quote pairs and USDT/USDC pairs through the public REST and WebSocket APIs. Master and virtual sub-account hierarchies allow per-strategy IP restriction and granular asset-transfer controls. TradeDesk OTC supports INSTANT, MANUAL_DEFER and AUTO_DEFER settlement modes for larger flows.
- Connection methods
- REST for order placement and account queries. WebSocket streams for real-time market data and depth. WebSocket User Data Streams for account, balance and order events. Coins.ph requires a keep-alive ping every 5 minutes; idle WebSocket connections auto-disconnect after that window.
- Authentication
- API key and secret per strategy. The `X-COINS-APIKEY` header is scoped to route categories (TRADE-only, USER_DATA, USER_STREAM), with a default that permits all routes. Permissions are best scoped down per strategy. IP-based rate limits apply on top of permission scoping.
For specifics, refer to Coins.ph
Specific endpoints, rate-limit weights, symbol lists, fee tiers and version history live in Coins.ph's documentation. Treat these as the source of truth.
Section 03 · Build with AI
Build your Coins.ph strategy with AI
Pick an integration method, fork a TradingHost framework starter, and author your strategy in an AI IDE. Cursor, Claude Code, GitHub Copilot and CLI-based AI agents all work with the same GitHub-native deployment loop.
Native Coins.ph API
Direct control over Coins.ph-specific behaviour, sub-account hierarchies and PHP-quote order routing.
CCXT
Common interface across Coins.ph and other crypto exchanges. CCXT exposes Coins.ph spot via the unified `coinsph` class.
Freqtrade or Hummingbot
Neither framework lists Coins.ph as a first-class supported exchange today. Best path is custom or CCXT-backed implementations.
Custom connector
Your own internal trading engine or proprietary Coins.ph integration against the REST and WebSocket APIs.
Framework support for Coins.ph products
Coverage varies by framework. Coins.ph is spot-only at the venue level (no native perps or options), so the matrix is narrow by design. CCXT exposes Coins.ph spot through its unified `coinsph` class. Neither Freqtrade nor Hummingbot lists Coins.ph as a first-class supported exchange today; native API access reaches everything Coins.ph publishes.
✓ confirmed support per official framework docs. "no" indicates not officially documented as supported. Workflow links target /workflows/ pages currently in authoring.
TradingHost does not force a framework. It runs your project.
Author with AI
The framework starters above pair naturally with AI IDEs. The TradingHost MCP control surface closes the loop: AI tools can inspect deployments, review logs and manage the runtime alongside you, never the trade execution path.
Section 04 · Run on TradingHost
Run your code on TradingHost
Coins.ph provides the exchange and API access. TradingHost provides the production environment where your Coins.ph-connected strategy runs.
Instead of running strategy code on a laptop, desktop machine, generic VPS or manually configured server, you deploy from GitHub into a TradingHost-managed container runtime.
You
- Your repo contains your code.
- Your deployment defines how it runs.
- Your strategy connects to Coins.ph.
TradingHost
- Keeps the runtime online.
- Surfaces logs and health checks.
- Region selection.
- Controlled deployment surface.
Deployment flow
- STEP 01
Connect GitHub
Authorise TradingHost to access your GitHub account.
- STEP 02
Link a repo or start from a framework
Point TradingHost at your existing strategy repo, or fork a TradingHost framework runtime (CCXT) for a working baseline against the Coins.ph REST and WebSocket APIs.
- STEP 03
Deploy into a TradingHost container
Pick a region (EU or US-East), supply the environment values your strategy needs (Coins.ph API key, secret, sub-account identifiers), and deploy. TradingHost builds your container from the repo and runs your strategy on managed Kubernetes infrastructure. No local Docker install required.
- STEP 04
Monitor logs and health
Watch live logs, health and runtime state from the TradingHost dashboard. The same surface is reachable through MCP from any AI IDE, so Cursor, Claude Code or a CLI agent can read deployment state and manage the runtime alongside you.
- STEP 05
Update and redeploy
Push changes to your GitHub main branch and TradingHost redeploys automatically.
Section 05 · Operational notes
Operational notes for Coins.ph
Things that bite you when you actually run a Coins.ph strategy in a containerised cloud runtime, not in Coins.ph's docs, not in framework READMEs. Every claim below is quoted or paraphrased from Coins.ph's own documentation; the deployment-side guidance is from running these strategies on TradingHost.
01 · Rate limits
IP-based 120 req/min per endpoint; HTTP 418 bans escalate from 2 minutes to 3 days
Coins.ph enforces an IP-based rate limit of 120 requests per minute per endpoint on the REST API. Repeat violations escalate the ban window from 2 minutes through to 3 days. Cloud runtimes that reschedule containers across pods can trip the same IP repeatedly. On TradingHost, container egress IPs are pinned per region, so the right pattern is to size your request cadence to the published per-endpoint limit and back off on HTTP 418 with exponential jitter rather than retrying immediately.
02 · WebSocket keep-alive
Idle WebSocket connections auto-disconnect after 5 minutes without a ping
Coins.ph requires a keep-alive ping every 5 minutes on WebSocket connections. Inactivity longer than that triggers an auto-disconnect. Strategies running 24/7 in a container must implement a heartbeat loop and a reconnect strategy with backoff. Lost subscriptions are silent: orders placed via REST during a stale WebSocket session still land, but order-state callbacks stop firing until the connection is re-established.
03 · API key scopes
`X-COINS-APIKEY` scopes default to all routes; scope down per strategy
The `X-COINS-APIKEY` header is scoped to route categories (TRADE-only, USER_DATA, USER_STREAM) but defaults to permitting all routes. The safer pattern is one scoped key per strategy with only the route categories that strategy needs. A leaked TRADE-only key cannot read other users' balances; a leaked default-scope key can do everything the account is permitted to do. Strategies should never need withdrawal permission.
04 · OTC settlement modes
TradeDesk OTC supports INSTANT, MANUAL_DEFER and AUTO_DEFER
For larger flows that route through the Coins.ph TradeDesk OTC desk rather than the public orderbook, settlement is one of three modes: INSTANT (executes immediately at the agreed price), MANUAL_DEFER (settlement at a future time you confirm), AUTO_DEFER (settlement deferred automatically per the desk's schedule). Strategies that integrate the TradeDesk path must encode the settlement-mode choice as a first-class config, because the position lifecycle differs materially between INSTANT and the deferred modes.
05 · Fiat rail limits
INSTAPAY and SWIFTPAY_PESONET have separate daily, monthly and annual ceilings
PHP cash-out via INSTAPAY (real-time, 24/7) and SWIFTPAY_PESONET (batch, business-day) operate under separate daily, monthly and annual limits that apply at the account level rather than per-strategy. A strategy that targets PHP fiat off-ramps must budget against the institutional TradeDesk ceilings published in your Coins.ph account; quota exhaustion shows up as deferred or rejected withdrawal requests rather than API errors. Plan strategy capital deployment with the rails in mind, not the orderbook.
06 · Sub-accounts
Master and virtual sub-account hierarchies give per-strategy IP and transfer isolation
Coins.ph supports master/virtual sub-account hierarchies with granular IP restriction and asset-transfer controls. The right pattern for multi-strategy deployments is one virtual sub-account per strategy, each with its own scoped API key, IP whitelist tied to the TradingHost region egress, and explicit transfer allowance. Failures in one strategy do not affect another, and the blast radius of a leaked key is contained to the virtual sub-account's balances.
Section 06 · Built for
Built for
TradingHost Coins.ph runtimes are best suited to:
- Developers building strategies in AI IDEs (Cursor, Claude Code)
- Systematic crypto traders
- Quant developers
- CCXT users
- Teams moving from VPS hosting to containerised deployment
Connecting GitHub and creating your first strategy is free.
Section 08 · FAQ
FAQ
No. TradingHost is independent and is not affiliated with Coins.ph.
No. Your strategy code connects to Coins.ph and sends instructions according to your own logic, account permissions and integration method. TradingHost provides the runtime where that code runs.
No. Coins.ph API access is provided by Coins.ph. You are responsible for your Coins.ph account, API permissions, credentials and compliance with Coins.ph’s terms.
No. TradingHost is the cloud runtime where your strategy code runs. We do not provide signals, AI prediction models or pre-built bots. With TradingHost you write or generate the strategy yourself (often with Cursor or Claude Code), keep it in GitHub as your code, and use TradingHost to run it in production. 3Commas, Cryptohopper and similar products own the strategy logic; TradingHost runs your strategy.
AWS and DigitalOcean give you raw compute. You handle OS updates, container orchestration, log shipping, secret rotation, region failover and uptime monitoring yourself. TradingHost gives you a managed runtime purpose-built for trading strategies: GitHub-native deployment, MCP-driven control from AI IDEs, log and health surfaces out of the box. If you want to operate the infrastructure yourself, AWS works. If you want the runtime as a managed service, TradingHost is the shorter path.
Yes. TradingHost runs Python strategies; pick the framework runtime that matches your stack or deploy your own repo.
Yes. TradingHost supports any language that can run inside a container.
Yes. CCXT ships a unified `coinsph` class that covers spot trading on Coins.ph PHP-quote pairs. Drop your CCXT strategy into a container, point it at GitHub, and TradingHost runs it like any other Python or Node project. See the CCXT framework runtime for the full setup story.
Yes. Coins.ph PHP-quote pairs (BTCPHP, ETHPHP, USDCPHP, and others) are reached through the same REST and WebSocket APIs as the stablecoin pairs. The strategy code inside your container authenticates with your Coins.ph API key, and TradingHost is venue-agnostic at the runtime level. PHP funding rails (INSTAPAY, SWIFTPAY_PESONET) and TradeDesk OTC settlement happen on Coins.ph, not inside TradingHost.
Yes, if your project is designed that way. You can run multiple strategy processes or services inside one runtime, or separate them into different runtimes for isolation and operational clarity. For Coins.ph specifically, pair each strategy with a virtual sub-account so blast radius is contained at the venue level too. See the TradingHost runtime page for the multi-strategy model.
The fastest path is to fork a TradingHost framework runtime: CCXT for a ready-to-deploy project. Or connect your own GitHub strategy repo. Linking a GitHub repo and creating a strategy is free; runtime plans are listed on the pricing page.
In your GitHub-controlled secrets workflow. TradingHost reads them at runtime through GitHub repository secrets, environment secrets or your own approved secret-management process. TradingHost does not need custody of your API key and secret. See platform secrets for the full handling model.
No. Strategies should never need withdrawal permissions. Scope `X-COINS-APIKEY` to TRADE-only or USER_DATA for the route categories your strategy actually uses, and keep withdrawal off the key entirely.
Yes. TradingHost supports MCP-based control for AI IDEs including Cursor, Claude Code, GitHub Copilot and CLI-based AI agents. AI tools can inspect deployments, review logs, restart strategies and manage runtime workflows. MCP is a control and observability surface, not the trade execution path. See the MCP control surface for the full picture.
Both. The MCP control surface works equally well from CLI-based agents (Claude Code CLI, custom MCP clients, scripted MCP calls) and from inside an IDE. The GitHub-native deployment loop also works without any AI tooling: a regular git push to your main branch triggers a redeploy.
The runtime detects the crash and exposes the relevant logs and health information. Where supported, the affected strategy can be restarted without disrupting other strategies running in the same container. Your strategy code is still responsible for safe error handling, duplicate-order protection and risk controls. See observability for the logs and health surface.
Coins.ph enforces an IP-based 120 req/min per endpoint rate limit and escalates HTTP 418 bans from 2 minutes through to 3 days on repeat violations. The fix is to size your request cadence to the published per-endpoint limit, back off with exponential jitter on the first 418 rather than retrying immediately, and avoid bursty patterns from poll loops. See the Operational notes section above for the full guidance.
TradingHost runs in the EU and US-East regions. Pick the region closest to the matching engine your strategy depends on. See the regions page for routing and proximity details.
No. TradingHost is focused on production runtime and deployment. Backtesting belongs in your research stack, framework or AlgoBuilder.