The above command returns JSON structured like this: json [ { "id": 0, "coin": "string", "address": "string", "name": "string", "balance": "string" } ] This endpoint retrieves all wallets. #### HTTP Request `GET /v1/api/wallets` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | No | Filter wallets by coin (e.g. "MINTME") #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Wallet ID coin | string | Coin name address | string | Wallet address name | string | Wallet name balance | string | Wallet balance ### Create a New Wallet python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "POST" request_path = "/wallets" data = { "coin": "MINTME", "name": "mywallet" } body = json.dumps(data) signature = generate_sign(secret_key, timestamp, method, request_path, body=body) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase, "Content-Type": "application/json" } response = requests.post(base_url + request_path, data=body, headers=headers) > The above command returns JSON structured like this: json { "id": 0, "coin": "string", "address": "string", "name": "string", "balance": "string" } This endpoint creates a new wallet. #### HTTP Request `POST /v1/api/wallets` #### Request Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin name (e.g. "MINTME") name | string | No | Wallet name #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Wallet ID coin | string | Coin name address | string | Wallet address name | string | Wallet name balance | string | Wallet balance ### Get a Specific Wallet python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/wallets/{wallet_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": 0, "coin": "string", "address": "string", "name": "string", "balance": "string" } This endpoint retrieves a specific wallet by its ID. #### HTTP Request `GET /v1/api/wallets/{wallet_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Wallet ID coin | string | Coin name address | string | Wallet address name | string | Wallet name balance | string | Wallet balance ### Update Wallet Name python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" timestamp = int(time.time() * 1000) method = "PUT" request_path = f"/wallets/{wallet_id}" data = { "name": "newname" } body = json.dumps(data) signature = generate_sign(secret_key, timestamp, method, request_path, body=body) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase, "Content-Type": "application/json" } response = requests.put(base_url + request_path, data=body, headers=headers) > The above command returns JSON structured like this: json { "id": 0, "coin": "string", "address": "string", "name": "string", "balance": "string" } This endpoint updates the name of a specific wallet. #### HTTP Request `PUT /v1/api/wallets/{wallet_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID #### Request Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- name | string | Yes | New wallet name #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Wallet ID coin | string | Coin name address | string | Wallet address name | string | Wallet name balance | string | Wallet balance ### Get Wallet Transactions python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/wallets/{wallet_id}/transactions" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": 0, "transaction_id": "string", "sender": "string", "receiver": "string", "amount": "string", "fee": "string", "timestamp": "string", "memo": "string", "status": "string" } ] This endpoint retrieves all transactions for a specific wallet. #### HTTP Request `GET /v1/api/wallets/{wallet_id}/transactions` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- offset | int | No | Offset for pagination (default: 0) limit | int | No | Number of transactions to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Transaction ID transaction_id | string | Blockchain transaction ID sender | string | Sender address receiver | string | Receiver address amount | string | Transaction amount fee | string | Transaction fee timestamp | string | Transaction timestamp (ISO 8601) memo | string | Transaction memo status | string | Transaction status (pending, confirmed, failed) ### Get Wallet Balance python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/wallets/{wallet_id}/balance" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "balance": "string" } This endpoint retrieves the balance of a specific wallet. #### HTTP Request `GET /v1/api/wallets/{wallet_id}/balance` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID #### Response Fields Field | Type | Description --------- | ------- | ----------- balance | string | Wallet balance ### Create a Transaction python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" timestamp = int(time.time() * 1000) method = "POST" request_path = f"/wallets/{wallet_id}/transactions" data = { "receiver": "receiver_address", "amount": "1.0", "memo": "test transaction" } body = json.dumps(data) signature = generate_sign(secret_key, timestamp, method, request_path, body=body) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase, "Content-Type": "application/json" } response = requests.post(base_url + request_path, data=body, headers=headers) > The above command returns JSON structured like this: json { "id": 0, "transaction_id": "string", "sender": "string", "receiver": "string", "amount": "string", "fee": "string", "timestamp": "string", "memo": "string", "status": "string" } This endpoint creates a new transaction from a specific wallet. #### HTTP Request `POST /v1/api/wallets/{wallet_id}/transactions` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID #### Request Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- receiver | string | Yes | Receiver address amount | string | Yes | Amount to send memo | string | No | Transaction memo #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Transaction ID transaction_id | string | Blockchain transaction ID sender | string | Sender address receiver | string | Receiver address amount | string | Transaction amount fee | string | Transaction fee timestamp | string | Transaction timestamp (ISO 8601) memo | string | Transaction memo status | string | Transaction status (pending, confirmed, failed) ### Get a Specific Transaction python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" transaction_id = "transaction_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/wallets/{wallet_id}/transactions/{transaction_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": 0, "transaction_id": "string", "sender": "string", "receiver": "string", "amount": "string", "fee": "string", "timestamp": "string", "memo": "string", "status": "string" } This endpoint retrieves a specific transaction by its ID. #### HTTP Request `GET /v1/api/wallets/{wallet_id}/transactions/{transaction_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID transaction_id | string | Yes | Transaction ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Transaction ID transaction_id | string | Blockchain transaction ID sender | string | Sender address receiver | string | Receiver address amount | string | Transaction amount fee | string | Transaction fee timestamp | string | Transaction timestamp (ISO 8601) memo | string | Transaction memo status | string | Transaction status (pending, confirmed, failed) ## Coin ### Get All Coins python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/coins" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "name": "string", "symbol": "string", "address": "string", "decimals": 0, "type": "string", "website": "string", "explorer": "string", "status": "string", "price_usd": "string" } ] This endpoint retrieves all coins available on MINTme. #### HTTP Request `GET /v1/api/coins` #### Response Fields Field | Type | Description --------- | ------- | ----------- name | string | Coin name symbol | string | Coin symbol address | string | Coin contract address decimals | int | Number of decimals type | string | Coin type (token or coin) website | string | Coin website URL explorer | string | Blockchain explorer URL status | string | Coin status (active, inactive) price_usd | string | Current price in USD ### Get a Specific Coin python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" coin = "MINTME" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/coins/{coin}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "name": "string", "symbol": "string", "address": "string", "decimals": 0, "type": "string", "website": "string", "explorer": "string", "status": "string", "price_usd": "string" } This endpoint retrieves a specific coin by its symbol. #### HTTP Request `GET /v1/api/coins/{coin}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin symbol (e.g. "MINTME") #### Response Fields Field | Type | Description --------- | ------- | ----------- name | string | Coin name symbol | string | Coin symbol address | string | Coin contract address decimals | int | Number of decimals type | string | Coin type (token or coin) website | string | Coin website URL explorer | string | Blockchain explorer URL status | string | Coin status (active, inactive) price_usd | string | Current price in USD ### Get Coin Price History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" coin = "MINTME" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/coins/{coin}/price_history" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "timestamp": "string", "price": "string" } ] This endpoint retrieves price history for a specific coin. #### HTTP Request `GET /v1/api/coins/{coin}/price_history` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin symbol (e.g. "MINTME") #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- start | string | No | Start date (YYYY-MM-DD) end | string | No | End date (YYYY-MM-DD) interval | string | No | Time interval (daily, hourly, minute) #### Response Fields Field | Type | Description --------- | ------- | ----------- timestamp | string | Timestamp (ISO 8601) price | string | Price in USD at this timestamp ## Market ### Get Order Book python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" market = "MINTME_BTC" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/markets/{market}/orderbook" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "bids": [ [ "string", "string" ] ], "asks": [ [ "string", "string" ] ] } This endpoint retrieves the order book for a specific market. #### HTTP Request `GET /v1/api/markets/{market}/orderbook` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | Yes | Market symbol (e.g. "MINTME_BTC") #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- depth | int | No | Depth of order book to retrieve (default: 20) #### Response Fields Field | Type | Description --------- | ------- | ----------- bids | array | Array of bid orders [price, amount] asks | array | Array of ask orders [price, amount] ### Get Recent Trades python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" market = "MINTME_BTC" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/markets/{market}/trades" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": 0, "price": "string", "amount": "string", "total": "string", "side": "string", "timestamp": "string" } ] This endpoint retrieves recent trades for a specific market. #### HTTP Request `GET /v1/api/markets/{market}/trades` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | Yes | Market symbol (e.g. "MINTME_BTC") #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- limit | int | No | Number of trades to retrieve (default: 50, max: 100) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Trade ID price | string | Trade price amount | string | Trade amount total | string | Total value (price * amount) side | string | Trade side (buy or sell) timestamp | string | Trade timestamp (ISO 8601) ### Get Market Summary python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" market = "MINTME_BTC" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/markets/{market}/summary" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "high": "string", "low": "string", "volume": "string", "last": "string", "change": "string", "timestamp": "string" } This endpoint retrieves summary statistics for a specific market. #### HTTP Request `GET /v1/api/markets/{market}/summary` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | Yes | Market symbol (e.g. "MINTME_BTC") #### Response Fields Field | Type | Description --------- | ------- | ----------- high | string | Highest price in last 24 hours low | string | Lowest price in last 24 hours volume | string | Total volume traded in last 24 hours last | string | Last traded price change | string | Percentage change in last 24 hours timestamp | string | Timestamp of last trade (ISO 8601) ### Get Market History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" market = "MINTME_BTC" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/markets/{market}/history" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "timestamp": "string", "open": "string", "high": "string", "low": "string", "close": "string", "volume": "string" } ] This endpoint retrieves historical data for a specific market. #### HTTP Request `GET /v1/api/markets/{market}/history` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | Yes | Market symbol (e.g. "MINTME_BTC") #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- start | string | No | Start date (YYYY-MM-DD) end | string | No | End date (YYYY-MM-DD) interval | string | No | Time interval (daily, hourly, minute) #### Response Fields Field | Type | Description --------- | ------- | ----------- timestamp | string | Timestamp (ISO 8601) open | string | Opening price high | string | Highest price low | string | Lowest price close | string | Closing price volume | string | Volume traded ## Order ### Get Open Orders python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/orders" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": "string", "market": "string", "type": "string", "side": "string", "price": "string", "amount": "string", "filled": "string", "remaining": "string", "status": "string", "timestamp": "string" } ] This endpoint retrieves all open orders. #### HTTP Request `GET /v1/api/orders` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | No | Filter orders by market (e.g. "MINTME_BTC") limit | int | No | Number of orders to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Order ID market | string | Market symbol type | string | Order type (limit, market) side | string | Order side (buy or sell) price | string | Order price amount | string | Order amount filled | string | Amount filled remaining | string | Amount remaining status | string | Order status (open, filled, canceled) timestamp | string | Order creation timestamp (ISO 8601) ### Create a New Order python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "POST" request_path = "/orders" data = { "market": "MINTME_BTC", "side": "buy", "type": "limit", "price": "0.000001", "amount": "100" } body = json.dumps(data) signature = generate_sign(secret_key, timestamp, method, request_path, body=body) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase, "Content-Type": "application/json" } response = requests.post(base_url + request_path, data=body, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "market": "string", "type": "string", "side": "string", "price": "string", "amount": "string", "filled": "string", "remaining": "string", "status": "string", "timestamp": "string" } This endpoint creates a new order. #### HTTP Request `POST /v1/api/orders` #### Request Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | Yes | Market symbol (e.g. "MINTME_BTC") side | string | Yes | Order side (buy or sell) type | string | Yes | Order type (limit or market) price | string | No | Price per unit (required for limit orders) amount | string | Yes | Amount to buy/sell client_id | string | No | Client order ID (optional) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Order ID market | string | Market symbol type | string | Order type side | string | Order side price | string | Order price amount | string | Order amount filled | string | Amount filled remaining | string | Amount remaining status | string | Order status timestamp | string | Order creation timestamp (ISO 8601) ### Get Order History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/orders/history" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": "string", "market": "string", "type": "string", "side": "string", "price": "string", "amount": "string", "filled": "string", "remaining": "string", "status": "string", "timestamp": "string", "updated_at": "string" } ] This endpoint retrieves order history. #### HTTP Request `GET /v1/api/orders/history` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | No | Filter orders by market (e.g. "MINTME_BTC") offset | int | No | Offset for pagination (default: 0) limit | int | No | Number of orders to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Order ID market | string | Market symbol type | string | Order type side | string | Order side price | string | Order price amount | string | Order amount filled | string | Amount filled remaining | string | Amount remaining status | string | Order status timestamp | string | Order creation timestamp (ISO 8601) updated_at | string | Last update timestamp (ISO 8601) ### Get a Specific Order python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" order_id = "order_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/orders/{order_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "market": "string", "type": "string", "side": "string", "price": "string", "amount": "string", "filled": "string", "remaining": "string", "status": "string", "timestamp": "string", "updated_at": "string" } This endpoint retrieves a specific order by its ID. #### HTTP Request `GET /v1/api/orders/{order_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- order_id | string | Yes | Order ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Order ID market | string | Market symbol type | string | Order type side | string | Order side price | string | Order price amount | string | Order amount filled | string | Amount filled remaining | string | Amount remaining status | string | Order status timestamp | string | Order creation timestamp (ISO 8601) updated_at | string | Last update timestamp (ISO 8601) ### Cancel an Order python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" order_id = "order_id" timestamp = int(time.time() * 1000) method = "DELETE" request_path = f"/orders/{order_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.delete(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "market": "string", "type": "string", "side": "string", "price": "string", "amount": "string", "filled": "string", "remaining": "string", "status": "string", "timestamp": "string", "updated_at": "string" } This endpoint cancels a specific order. #### HTTP Request `DELETE /v1/api/orders/{order_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- order_id | string | Yes | Order ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Order ID market | string | Market symbol type | string | Order type side | string | Order side price | string | Order price amount | string | Order amount filled | string | Amount filled remaining | string | Amount remaining status | string | Order status timestamp | string | Order creation timestamp (ISO 8601) updated_at | string | Last update timestamp (ISO 8601) ### Cancel All Orders python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "DELETE" request_path = "/orders" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.delete(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "message": "string" } This endpoint cancels all open orders. #### HTTP Request `DELETE /v1/api/orders` #### Response Fields Field | Type | Description --------- | ------- | ----------- message | string | Result message ## Trade ### Get Trade History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/trades" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": "string", "order_id": "string", "market": "string", "side": "string", "price": "string", "amount": "string", "total": "string", "fee": "string", "timestamp": "string" } ] This endpoint retrieves trade history. #### HTTP Request `GET /v1/api/trades` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | No | Filter trades by market (e.g. "MINTME_BTC") offset | int | No | Offset for pagination (default: 0) limit | int | No | Number of trades to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Trade ID order_id | string | Order ID associated with this trade market | string | Market symbol side | string | Trade side (buy or sell) price | string | Trade price amount | string | Trade amount total | string | Total value (price * amount) fee | string | Fee paid timestamp | string | Trade timestamp (ISO 8601) ### Get a Specific Trade python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" trade_id = "trade_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/trades/{trade_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "order_id": "string", "market": "string", "side": "string", "price": "string", "amount": "string", "total": "string", "fee": "string", "timestamp": "string" } This endpoint retrieves a specific trade by its ID. #### HTTP Request `GET /v1/api/trades/{trade_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- trade_id | string | Yes | Trade ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Trade ID order_id | string | Order ID associated with this trade market | string | Market symbol side | string | Trade side (buy or sell) price | string | Trade price amount | string | Trade amount total | string | Total value (price * amount) fee | string | Fee paid timestamp | string | Trade timestamp (ISO 8601) ## Deposit & Withdrawal ### Get Deposit Address python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" coin = "MINTME" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/deposits/{coin}/address" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "address": "string", "memo": "string" } This endpoint retrieves the deposit address for a specific coin. #### HTTP Request `GET /v1/api/deposits/{coin}/address` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin symbol (e.g. "MINTME") #### Response Fields Field | Type | Description --------- | ------- | ----------- address | string | Deposit address memo | string | Memo/tag for the deposit (if applicable) ### Get Deposit History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/deposits" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } ] This endpoint retrieves deposit history. #### HTTP Request `GET /v1/api/deposits` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | No | Filter deposits by coin (e.g. "MINTME") offset | int | No | Offset for pagination (default: 0) limit | int | No | Number of deposits to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Deposit ID coin | string | Coin symbol amount | string | Deposit amount address | string | Deposit address txid | string | Transaction ID status | string | Deposit status (pending, completed, failed) timestamp | string | Deposit timestamp (ISO 8601) ### Get a Specific Deposit python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" deposit_id = "deposit_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/deposits/{deposit_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } This endpoint retrieves a specific deposit by its ID. #### HTTP Request `GET /v1/api/deposits/{deposit_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- deposit_id | string | Yes | Deposit ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Deposit ID coin | string | Coin symbol amount | string | Deposit amount address | string | Deposit address txid | string | Transaction ID status | string | Deposit status timestamp | string | Deposit timestamp (ISO 8601) ### Create a Withdrawal python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "POST" request_path = "/withdrawals" data = { "coin": "MINTME", "address": "receiver_address", "amount": "1.0", "memo": "test withdrawal" } body = json.dumps(data) signature = generate_sign(secret_key, timestamp, method, request_path, body=body) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase, "Content-Type": "application/json" } response = requests.post(base_url + request_path, data=body, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } This endpoint creates a new withdrawal. #### HTTP Request `POST /v1/api/withdrawals` #### Request Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin symbol (e.g. "MINTME") address | string | Yes | Withdrawal address amount | string | Yes | Amount to withdraw memo | string | No | Memo/tag for the withdrawal (if applicable) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Withdrawal ID coin | string | Coin symbol amount | string | Withdrawal amount address | string | Withdrawal address txid | string | Transaction ID status | string | Withdrawal status (pending, processing, completed, failed) timestamp | string | Withdrawal timestamp (ISO 8601) ### Get Withdrawal History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/withdrawals" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } ] This endpoint retrieves withdrawal history. #### HTTP Request `GET /v1/api/withdrawals` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | No | Filter withdrawals by coin (e.g. "MINTME") offset | int | No | Offset for pagination (default: 0) limit | int | No | Number of withdrawals to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Withdrawal ID coin | string | Coin symbol amount | string | Withdrawal amount address | string | Withdrawal address txid | string | Transaction ID status | string | Withdrawal status timestamp | string | Withdrawal timestamp (ISO 8601) ### Get a Specific Withdrawal python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" withdrawal_id = "withdrawal_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/withdrawals/{withdrawal_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } This endpoint retrieves a specific withdrawal by its ID. #### HTTP Request `GET /v1/api/withdrawals/{withdrawal_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- withdrawal_id | string | Yes | Withdrawal ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Withdrawal ID coin | string | Coin symbol amount | string | Withdrawal amount address | string | Withdrawal address txid | string | Transaction ID status | string | Withdrawal status timestamp | string | Withdrawal timestamp (ISO 8601) ### Cancel a Withdrawal python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" withdrawal_id = "withdrawal_id" timestamp = int(time.time() * 1000) method = "DELETE" request_path = f"/withdrawals/{withdrawal_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.delete(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } This endpoint cancels a specific withdrawal (if it's still pending). #### HTTP Request `DELETE /v1/api/withdrawals/{withdrawal_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- withdrawal_id | string | Yes | Withdrawal ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Withdrawal ID coin | string | Coin symbol amount | string | Withdrawal amount address | string | Withdrawal address txid | string | Transaction ID status | string | Withdrawal status timestamp | string | Withdrawal timestamp (ISO 8601) ## Account ### Get Account Information python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/account" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "email": "string", "username": "string", "tier": "string", "limits": { "withdrawal": { "daily": "string", "monthly": "string" }, "deposit": { "daily": "string", "monthly": "string" }, "trade": { "daily": "string", "monthly": "string" } }, "verification_level": "string", "kyc_status": "string" } This endpoint retrieves account information. #### HTTP Request `GET /v1/api/account` #### Response Fields Field | Type | Description --------- | ------- | ----------- email | string | Account email address username | string | Account username tier | string | Account tier level limits | object | Account limits verification_level | string | Verification level kyc_status | string | KYC status ### Get Account Balances python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/account/balances" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "coin": "string", "total": "string", "available": "string", "in_orders": "string" } ] This endpoint retrieves all account balances. #### HTTP Request `GET /v1/api/account/balances` #### Response Fields Field | Type | Description --------- | ------- | ----------- coin | string | Coin symbol total | string | Total balance available | string | Available balance (not locked in orders) in_orders | string | Balance locked in orders ### Get a Specific Account Balance python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" coin = "MINTME" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/account/balances/{coin}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "coin": "string", "total": "string", "available": "string", "in_orders": "string" } This endpoint retrieves a specific account balance by coin. #### HTTP Request `GET /v1/api/account/balances/{coin}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin symbol (e.g. "MINTME") #### Response Fields Field | Type | Description --------- | ------- | ----------- coin | string | Coin symbol total | string | Total balance available | string | Available balance (not locked in orders) in_orders | string | Balance locked in orders ### Get Account Limits python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/account/limits" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "withdrawal": { "daily": "string", "monthly": "string" }, "deposit": { "daily": "string", "monthly": "string" }, "trade": { "daily": "string", "monthly": "string" } } This endpoint retrieves account limits. #### HTTP Request `GET /v1/api/account/limits` #### Response Fields Field | Type | Description --------- | ------- | ----------- withdrawal | object | Withdrawal limits deposit | object | Deposit limits trade | object | Trade limits ### Get API Key Information python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/account/api_key" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "name": "string", "permissions": [ "string" ], "ip_restrictions": [ "string" ], "created_at": "string", "last_used": "string" } This endpoint retrieves information about the current API key. #### HTTP Request `GET /v1/api/account/api_key` #### Response Fields Field | Type | Description --------- | ------- | ----------- name | string | API key name permissions | array | List of permissions granted to this key ip_restrictions | array | List of IP restrictions created_at | string | Creation timestamp (ISO 8601) last_used | string | Last used timestamp (ISO 8601)" /> The above command returns JSON structured like this: json [ { "id": 0, "coin": "string", "address": "string", "name": "string", "balance": "string" } ] This endpoint retrieves all wallets. #### HTTP Request `GET /v1/api/wallets` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | No | Filter wallets by coin (e.g. "MINTME") #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Wallet ID coin | string | Coin name address | string | Wallet address name | string | Wallet name balance | string | Wallet balance ### Create a New Wallet python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "POST" request_path = "/wallets" data = { "coin": "MINTME", "name": "mywallet" } body = json.dumps(data) signature = generate_sign(secret_key, timestamp, method, request_path, body=body) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase, "Content-Type": "application/json" } response = requests.post(base_url + request_path, data=body, headers=headers) > The above command returns JSON structured like this: json { "id": 0, "coin": "string", "address": "string", "name": "string", "balance": "string" } This endpoint creates a new wallet. #### HTTP Request `POST /v1/api/wallets` #### Request Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin name (e.g. "MINTME") name | string | No | Wallet name #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Wallet ID coin | string | Coin name address | string | Wallet address name | string | Wallet name balance | string | Wallet balance ### Get a Specific Wallet python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/wallets/{wallet_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": 0, "coin": "string", "address": "string", "name": "string", "balance": "string" } This endpoint retrieves a specific wallet by its ID. #### HTTP Request `GET /v1/api/wallets/{wallet_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Wallet ID coin | string | Coin name address | string | Wallet address name | string | Wallet name balance | string | Wallet balance ### Update Wallet Name python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" timestamp = int(time.time() * 1000) method = "PUT" request_path = f"/wallets/{wallet_id}" data = { "name": "newname" } body = json.dumps(data) signature = generate_sign(secret_key, timestamp, method, request_path, body=body) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase, "Content-Type": "application/json" } response = requests.put(base_url + request_path, data=body, headers=headers) > The above command returns JSON structured like this: json { "id": 0, "coin": "string", "address": "string", "name": "string", "balance": "string" } This endpoint updates the name of a specific wallet. #### HTTP Request `PUT /v1/api/wallets/{wallet_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID #### Request Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- name | string | Yes | New wallet name #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Wallet ID coin | string | Coin name address | string | Wallet address name | string | Wallet name balance | string | Wallet balance ### Get Wallet Transactions python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/wallets/{wallet_id}/transactions" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": 0, "transaction_id": "string", "sender": "string", "receiver": "string", "amount": "string", "fee": "string", "timestamp": "string", "memo": "string", "status": "string" } ] This endpoint retrieves all transactions for a specific wallet. #### HTTP Request `GET /v1/api/wallets/{wallet_id}/transactions` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- offset | int | No | Offset for pagination (default: 0) limit | int | No | Number of transactions to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Transaction ID transaction_id | string | Blockchain transaction ID sender | string | Sender address receiver | string | Receiver address amount | string | Transaction amount fee | string | Transaction fee timestamp | string | Transaction timestamp (ISO 8601) memo | string | Transaction memo status | string | Transaction status (pending, confirmed, failed) ### Get Wallet Balance python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/wallets/{wallet_id}/balance" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "balance": "string" } This endpoint retrieves the balance of a specific wallet. #### HTTP Request `GET /v1/api/wallets/{wallet_id}/balance` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID #### Response Fields Field | Type | Description --------- | ------- | ----------- balance | string | Wallet balance ### Create a Transaction python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" timestamp = int(time.time() * 1000) method = "POST" request_path = f"/wallets/{wallet_id}/transactions" data = { "receiver": "receiver_address", "amount": "1.0", "memo": "test transaction" } body = json.dumps(data) signature = generate_sign(secret_key, timestamp, method, request_path, body=body) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase, "Content-Type": "application/json" } response = requests.post(base_url + request_path, data=body, headers=headers) > The above command returns JSON structured like this: json { "id": 0, "transaction_id": "string", "sender": "string", "receiver": "string", "amount": "string", "fee": "string", "timestamp": "string", "memo": "string", "status": "string" } This endpoint creates a new transaction from a specific wallet. #### HTTP Request `POST /v1/api/wallets/{wallet_id}/transactions` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID #### Request Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- receiver | string | Yes | Receiver address amount | string | Yes | Amount to send memo | string | No | Transaction memo #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Transaction ID transaction_id | string | Blockchain transaction ID sender | string | Sender address receiver | string | Receiver address amount | string | Transaction amount fee | string | Transaction fee timestamp | string | Transaction timestamp (ISO 8601) memo | string | Transaction memo status | string | Transaction status (pending, confirmed, failed) ### Get a Specific Transaction python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" transaction_id = "transaction_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/wallets/{wallet_id}/transactions/{transaction_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": 0, "transaction_id": "string", "sender": "string", "receiver": "string", "amount": "string", "fee": "string", "timestamp": "string", "memo": "string", "status": "string" } This endpoint retrieves a specific transaction by its ID. #### HTTP Request `GET /v1/api/wallets/{wallet_id}/transactions/{transaction_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID transaction_id | string | Yes | Transaction ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Transaction ID transaction_id | string | Blockchain transaction ID sender | string | Sender address receiver | string | Receiver address amount | string | Transaction amount fee | string | Transaction fee timestamp | string | Transaction timestamp (ISO 8601) memo | string | Transaction memo status | string | Transaction status (pending, confirmed, failed) ## Coin ### Get All Coins python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/coins" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "name": "string", "symbol": "string", "address": "string", "decimals": 0, "type": "string", "website": "string", "explorer": "string", "status": "string", "price_usd": "string" } ] This endpoint retrieves all coins available on MINTme. #### HTTP Request `GET /v1/api/coins` #### Response Fields Field | Type | Description --------- | ------- | ----------- name | string | Coin name symbol | string | Coin symbol address | string | Coin contract address decimals | int | Number of decimals type | string | Coin type (token or coin) website | string | Coin website URL explorer | string | Blockchain explorer URL status | string | Coin status (active, inactive) price_usd | string | Current price in USD ### Get a Specific Coin python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" coin = "MINTME" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/coins/{coin}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "name": "string", "symbol": "string", "address": "string", "decimals": 0, "type": "string", "website": "string", "explorer": "string", "status": "string", "price_usd": "string" } This endpoint retrieves a specific coin by its symbol. #### HTTP Request `GET /v1/api/coins/{coin}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin symbol (e.g. "MINTME") #### Response Fields Field | Type | Description --------- | ------- | ----------- name | string | Coin name symbol | string | Coin symbol address | string | Coin contract address decimals | int | Number of decimals type | string | Coin type (token or coin) website | string | Coin website URL explorer | string | Blockchain explorer URL status | string | Coin status (active, inactive) price_usd | string | Current price in USD ### Get Coin Price History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" coin = "MINTME" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/coins/{coin}/price_history" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "timestamp": "string", "price": "string" } ] This endpoint retrieves price history for a specific coin. #### HTTP Request `GET /v1/api/coins/{coin}/price_history` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin symbol (e.g. "MINTME") #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- start | string | No | Start date (YYYY-MM-DD) end | string | No | End date (YYYY-MM-DD) interval | string | No | Time interval (daily, hourly, minute) #### Response Fields Field | Type | Description --------- | ------- | ----------- timestamp | string | Timestamp (ISO 8601) price | string | Price in USD at this timestamp ## Market ### Get Order Book python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" market = "MINTME_BTC" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/markets/{market}/orderbook" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "bids": [ [ "string", "string" ] ], "asks": [ [ "string", "string" ] ] } This endpoint retrieves the order book for a specific market. #### HTTP Request `GET /v1/api/markets/{market}/orderbook` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | Yes | Market symbol (e.g. "MINTME_BTC") #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- depth | int | No | Depth of order book to retrieve (default: 20) #### Response Fields Field | Type | Description --------- | ------- | ----------- bids | array | Array of bid orders [price, amount] asks | array | Array of ask orders [price, amount] ### Get Recent Trades python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" market = "MINTME_BTC" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/markets/{market}/trades" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": 0, "price": "string", "amount": "string", "total": "string", "side": "string", "timestamp": "string" } ] This endpoint retrieves recent trades for a specific market. #### HTTP Request `GET /v1/api/markets/{market}/trades` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | Yes | Market symbol (e.g. "MINTME_BTC") #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- limit | int | No | Number of trades to retrieve (default: 50, max: 100) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Trade ID price | string | Trade price amount | string | Trade amount total | string | Total value (price * amount) side | string | Trade side (buy or sell) timestamp | string | Trade timestamp (ISO 8601) ### Get Market Summary python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" market = "MINTME_BTC" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/markets/{market}/summary" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "high": "string", "low": "string", "volume": "string", "last": "string", "change": "string", "timestamp": "string" } This endpoint retrieves summary statistics for a specific market. #### HTTP Request `GET /v1/api/markets/{market}/summary` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | Yes | Market symbol (e.g. "MINTME_BTC") #### Response Fields Field | Type | Description --------- | ------- | ----------- high | string | Highest price in last 24 hours low | string | Lowest price in last 24 hours volume | string | Total volume traded in last 24 hours last | string | Last traded price change | string | Percentage change in last 24 hours timestamp | string | Timestamp of last trade (ISO 8601) ### Get Market History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" market = "MINTME_BTC" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/markets/{market}/history" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "timestamp": "string", "open": "string", "high": "string", "low": "string", "close": "string", "volume": "string" } ] This endpoint retrieves historical data for a specific market. #### HTTP Request `GET /v1/api/markets/{market}/history` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | Yes | Market symbol (e.g. "MINTME_BTC") #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- start | string | No | Start date (YYYY-MM-DD) end | string | No | End date (YYYY-MM-DD) interval | string | No | Time interval (daily, hourly, minute) #### Response Fields Field | Type | Description --------- | ------- | ----------- timestamp | string | Timestamp (ISO 8601) open | string | Opening price high | string | Highest price low | string | Lowest price close | string | Closing price volume | string | Volume traded ## Order ### Get Open Orders python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/orders" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": "string", "market": "string", "type": "string", "side": "string", "price": "string", "amount": "string", "filled": "string", "remaining": "string", "status": "string", "timestamp": "string" } ] This endpoint retrieves all open orders. #### HTTP Request `GET /v1/api/orders` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | No | Filter orders by market (e.g. "MINTME_BTC") limit | int | No | Number of orders to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Order ID market | string | Market symbol type | string | Order type (limit, market) side | string | Order side (buy or sell) price | string | Order price amount | string | Order amount filled | string | Amount filled remaining | string | Amount remaining status | string | Order status (open, filled, canceled) timestamp | string | Order creation timestamp (ISO 8601) ### Create a New Order python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "POST" request_path = "/orders" data = { "market": "MINTME_BTC", "side": "buy", "type": "limit", "price": "0.000001", "amount": "100" } body = json.dumps(data) signature = generate_sign(secret_key, timestamp, method, request_path, body=body) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase, "Content-Type": "application/json" } response = requests.post(base_url + request_path, data=body, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "market": "string", "type": "string", "side": "string", "price": "string", "amount": "string", "filled": "string", "remaining": "string", "status": "string", "timestamp": "string" } This endpoint creates a new order. #### HTTP Request `POST /v1/api/orders` #### Request Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | Yes | Market symbol (e.g. "MINTME_BTC") side | string | Yes | Order side (buy or sell) type | string | Yes | Order type (limit or market) price | string | No | Price per unit (required for limit orders) amount | string | Yes | Amount to buy/sell client_id | string | No | Client order ID (optional) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Order ID market | string | Market symbol type | string | Order type side | string | Order side price | string | Order price amount | string | Order amount filled | string | Amount filled remaining | string | Amount remaining status | string | Order status timestamp | string | Order creation timestamp (ISO 8601) ### Get Order History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/orders/history" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": "string", "market": "string", "type": "string", "side": "string", "price": "string", "amount": "string", "filled": "string", "remaining": "string", "status": "string", "timestamp": "string", "updated_at": "string" } ] This endpoint retrieves order history. #### HTTP Request `GET /v1/api/orders/history` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | No | Filter orders by market (e.g. "MINTME_BTC") offset | int | No | Offset for pagination (default: 0) limit | int | No | Number of orders to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Order ID market | string | Market symbol type | string | Order type side | string | Order side price | string | Order price amount | string | Order amount filled | string | Amount filled remaining | string | Amount remaining status | string | Order status timestamp | string | Order creation timestamp (ISO 8601) updated_at | string | Last update timestamp (ISO 8601) ### Get a Specific Order python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" order_id = "order_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/orders/{order_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "market": "string", "type": "string", "side": "string", "price": "string", "amount": "string", "filled": "string", "remaining": "string", "status": "string", "timestamp": "string", "updated_at": "string" } This endpoint retrieves a specific order by its ID. #### HTTP Request `GET /v1/api/orders/{order_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- order_id | string | Yes | Order ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Order ID market | string | Market symbol type | string | Order type side | string | Order side price | string | Order price amount | string | Order amount filled | string | Amount filled remaining | string | Amount remaining status | string | Order status timestamp | string | Order creation timestamp (ISO 8601) updated_at | string | Last update timestamp (ISO 8601) ### Cancel an Order python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" order_id = "order_id" timestamp = int(time.time() * 1000) method = "DELETE" request_path = f"/orders/{order_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.delete(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "market": "string", "type": "string", "side": "string", "price": "string", "amount": "string", "filled": "string", "remaining": "string", "status": "string", "timestamp": "string", "updated_at": "string" } This endpoint cancels a specific order. #### HTTP Request `DELETE /v1/api/orders/{order_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- order_id | string | Yes | Order ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Order ID market | string | Market symbol type | string | Order type side | string | Order side price | string | Order price amount | string | Order amount filled | string | Amount filled remaining | string | Amount remaining status | string | Order status timestamp | string | Order creation timestamp (ISO 8601) updated_at | string | Last update timestamp (ISO 8601) ### Cancel All Orders python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "DELETE" request_path = "/orders" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.delete(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "message": "string" } This endpoint cancels all open orders. #### HTTP Request `DELETE /v1/api/orders` #### Response Fields Field | Type | Description --------- | ------- | ----------- message | string | Result message ## Trade ### Get Trade History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/trades" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": "string", "order_id": "string", "market": "string", "side": "string", "price": "string", "amount": "string", "total": "string", "fee": "string", "timestamp": "string" } ] This endpoint retrieves trade history. #### HTTP Request `GET /v1/api/trades` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | No | Filter trades by market (e.g. "MINTME_BTC") offset | int | No | Offset for pagination (default: 0) limit | int | No | Number of trades to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Trade ID order_id | string | Order ID associated with this trade market | string | Market symbol side | string | Trade side (buy or sell) price | string | Trade price amount | string | Trade amount total | string | Total value (price * amount) fee | string | Fee paid timestamp | string | Trade timestamp (ISO 8601) ### Get a Specific Trade python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" trade_id = "trade_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/trades/{trade_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "order_id": "string", "market": "string", "side": "string", "price": "string", "amount": "string", "total": "string", "fee": "string", "timestamp": "string" } This endpoint retrieves a specific trade by its ID. #### HTTP Request `GET /v1/api/trades/{trade_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- trade_id | string | Yes | Trade ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Trade ID order_id | string | Order ID associated with this trade market | string | Market symbol side | string | Trade side (buy or sell) price | string | Trade price amount | string | Trade amount total | string | Total value (price * amount) fee | string | Fee paid timestamp | string | Trade timestamp (ISO 8601) ## Deposit & Withdrawal ### Get Deposit Address python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" coin = "MINTME" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/deposits/{coin}/address" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "address": "string", "memo": "string" } This endpoint retrieves the deposit address for a specific coin. #### HTTP Request `GET /v1/api/deposits/{coin}/address` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin symbol (e.g. "MINTME") #### Response Fields Field | Type | Description --------- | ------- | ----------- address | string | Deposit address memo | string | Memo/tag for the deposit (if applicable) ### Get Deposit History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/deposits" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } ] This endpoint retrieves deposit history. #### HTTP Request `GET /v1/api/deposits` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | No | Filter deposits by coin (e.g. "MINTME") offset | int | No | Offset for pagination (default: 0) limit | int | No | Number of deposits to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Deposit ID coin | string | Coin symbol amount | string | Deposit amount address | string | Deposit address txid | string | Transaction ID status | string | Deposit status (pending, completed, failed) timestamp | string | Deposit timestamp (ISO 8601) ### Get a Specific Deposit python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" deposit_id = "deposit_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/deposits/{deposit_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } This endpoint retrieves a specific deposit by its ID. #### HTTP Request `GET /v1/api/deposits/{deposit_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- deposit_id | string | Yes | Deposit ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Deposit ID coin | string | Coin symbol amount | string | Deposit amount address | string | Deposit address txid | string | Transaction ID status | string | Deposit status timestamp | string | Deposit timestamp (ISO 8601) ### Create a Withdrawal python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "POST" request_path = "/withdrawals" data = { "coin": "MINTME", "address": "receiver_address", "amount": "1.0", "memo": "test withdrawal" } body = json.dumps(data) signature = generate_sign(secret_key, timestamp, method, request_path, body=body) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase, "Content-Type": "application/json" } response = requests.post(base_url + request_path, data=body, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } This endpoint creates a new withdrawal. #### HTTP Request `POST /v1/api/withdrawals` #### Request Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin symbol (e.g. "MINTME") address | string | Yes | Withdrawal address amount | string | Yes | Amount to withdraw memo | string | No | Memo/tag for the withdrawal (if applicable) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Withdrawal ID coin | string | Coin symbol amount | string | Withdrawal amount address | string | Withdrawal address txid | string | Transaction ID status | string | Withdrawal status (pending, processing, completed, failed) timestamp | string | Withdrawal timestamp (ISO 8601) ### Get Withdrawal History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/withdrawals" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } ] This endpoint retrieves withdrawal history. #### HTTP Request `GET /v1/api/withdrawals` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | No | Filter withdrawals by coin (e.g. "MINTME") offset | int | No | Offset for pagination (default: 0) limit | int | No | Number of withdrawals to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Withdrawal ID coin | string | Coin symbol amount | string | Withdrawal amount address | string | Withdrawal address txid | string | Transaction ID status | string | Withdrawal status timestamp | string | Withdrawal timestamp (ISO 8601) ### Get a Specific Withdrawal python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" withdrawal_id = "withdrawal_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/withdrawals/{withdrawal_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } This endpoint retrieves a specific withdrawal by its ID. #### HTTP Request `GET /v1/api/withdrawals/{withdrawal_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- withdrawal_id | string | Yes | Withdrawal ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Withdrawal ID coin | string | Coin symbol amount | string | Withdrawal amount address | string | Withdrawal address txid | string | Transaction ID status | string | Withdrawal status timestamp | string | Withdrawal timestamp (ISO 8601) ### Cancel a Withdrawal python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" withdrawal_id = "withdrawal_id" timestamp = int(time.time() * 1000) method = "DELETE" request_path = f"/withdrawals/{withdrawal_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.delete(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } This endpoint cancels a specific withdrawal (if it's still pending). #### HTTP Request `DELETE /v1/api/withdrawals/{withdrawal_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- withdrawal_id | string | Yes | Withdrawal ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Withdrawal ID coin | string | Coin symbol amount | string | Withdrawal amount address | string | Withdrawal address txid | string | Transaction ID status | string | Withdrawal status timestamp | string | Withdrawal timestamp (ISO 8601) ## Account ### Get Account Information python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/account" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "email": "string", "username": "string", "tier": "string", "limits": { "withdrawal": { "daily": "string", "monthly": "string" }, "deposit": { "daily": "string", "monthly": "string" }, "trade": { "daily": "string", "monthly": "string" } }, "verification_level": "string", "kyc_status": "string" } This endpoint retrieves account information. #### HTTP Request `GET /v1/api/account` #### Response Fields Field | Type | Description --------- | ------- | ----------- email | string | Account email address username | string | Account username tier | string | Account tier level limits | object | Account limits verification_level | string | Verification level kyc_status | string | KYC status ### Get Account Balances python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/account/balances" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "coin": "string", "total": "string", "available": "string", "in_orders": "string" } ] This endpoint retrieves all account balances. #### HTTP Request `GET /v1/api/account/balances` #### Response Fields Field | Type | Description --------- | ------- | ----------- coin | string | Coin symbol total | string | Total balance available | string | Available balance (not locked in orders) in_orders | string | Balance locked in orders ### Get a Specific Account Balance python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" coin = "MINTME" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/account/balances/{coin}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "coin": "string", "total": "string", "available": "string", "in_orders": "string" } This endpoint retrieves a specific account balance by coin. #### HTTP Request `GET /v1/api/account/balances/{coin}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin symbol (e.g. "MINTME") #### Response Fields Field | Type | Description --------- | ------- | ----------- coin | string | Coin symbol total | string | Total balance available | string | Available balance (not locked in orders) in_orders | string | Balance locked in orders ### Get Account Limits python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/account/limits" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "withdrawal": { "daily": "string", "monthly": "string" }, "deposit": { "daily": "string", "monthly": "string" }, "trade": { "daily": "string", "monthly": "string" } } This endpoint retrieves account limits. #### HTTP Request `GET /v1/api/account/limits` #### Response Fields Field | Type | Description --------- | ------- | ----------- withdrawal | object | Withdrawal limits deposit | object | Deposit limits trade | object | Trade limits ### Get API Key Information python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/account/api_key" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "name": "string", "permissions": [ "string" ], "ip_restrictions": [ "string" ], "created_at": "string", "last_used": "string" } This endpoint retrieves information about the current API key. #### HTTP Request `GET /v1/api/account/api_key` #### Response Fields Field | Type | Description --------- | ------- | ----------- name | string | API key name permissions | array | List of permissions granted to this key ip_restrictions | array | List of IP restrictions created_at | string | Creation timestamp (ISO 8601) last_used | string | Last used timestamp (ISO 8601)"> The above command returns JSON structured like this: json [ { "id": 0, "coin": "string", "address": "string", "name": "string", "balance": "string" } ] This endpoint retrieves all wallets. #### HTTP Request `GET /v1/api/wallets` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | No | Filter wallets by coin (e.g. "MINTME") #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Wallet ID coin | string | Coin name address | string | Wallet address name | string | Wallet name balance | string | Wallet balance ### Create a New Wallet python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "POST" request_path = "/wallets" data = { "coin": "MINTME", "name": "mywallet" } body = json.dumps(data) signature = generate_sign(secret_key, timestamp, method, request_path, body=body) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase, "Content-Type": "application/json" } response = requests.post(base_url + request_path, data=body, headers=headers) > The above command returns JSON structured like this: json { "id": 0, "coin": "string", "address": "string", "name": "string", "balance": "string" } This endpoint creates a new wallet. #### HTTP Request `POST /v1/api/wallets` #### Request Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin name (e.g. "MINTME") name | string | No | Wallet name #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Wallet ID coin | string | Coin name address | string | Wallet address name | string | Wallet name balance | string | Wallet balance ### Get a Specific Wallet python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/wallets/{wallet_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": 0, "coin": "string", "address": "string", "name": "string", "balance": "string" } This endpoint retrieves a specific wallet by its ID. #### HTTP Request `GET /v1/api/wallets/{wallet_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Wallet ID coin | string | Coin name address | string | Wallet address name | string | Wallet name balance | string | Wallet balance ### Update Wallet Name python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" timestamp = int(time.time() * 1000) method = "PUT" request_path = f"/wallets/{wallet_id}" data = { "name": "newname" } body = json.dumps(data) signature = generate_sign(secret_key, timestamp, method, request_path, body=body) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase, "Content-Type": "application/json" } response = requests.put(base_url + request_path, data=body, headers=headers) > The above command returns JSON structured like this: json { "id": 0, "coin": "string", "address": "string", "name": "string", "balance": "string" } This endpoint updates the name of a specific wallet. #### HTTP Request `PUT /v1/api/wallets/{wallet_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID #### Request Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- name | string | Yes | New wallet name #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Wallet ID coin | string | Coin name address | string | Wallet address name | string | Wallet name balance | string | Wallet balance ### Get Wallet Transactions python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/wallets/{wallet_id}/transactions" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": 0, "transaction_id": "string", "sender": "string", "receiver": "string", "amount": "string", "fee": "string", "timestamp": "string", "memo": "string", "status": "string" } ] This endpoint retrieves all transactions for a specific wallet. #### HTTP Request `GET /v1/api/wallets/{wallet_id}/transactions` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- offset | int | No | Offset for pagination (default: 0) limit | int | No | Number of transactions to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Transaction ID transaction_id | string | Blockchain transaction ID sender | string | Sender address receiver | string | Receiver address amount | string | Transaction amount fee | string | Transaction fee timestamp | string | Transaction timestamp (ISO 8601) memo | string | Transaction memo status | string | Transaction status (pending, confirmed, failed) ### Get Wallet Balance python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/wallets/{wallet_id}/balance" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "balance": "string" } This endpoint retrieves the balance of a specific wallet. #### HTTP Request `GET /v1/api/wallets/{wallet_id}/balance` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID #### Response Fields Field | Type | Description --------- | ------- | ----------- balance | string | Wallet balance ### Create a Transaction python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" timestamp = int(time.time() * 1000) method = "POST" request_path = f"/wallets/{wallet_id}/transactions" data = { "receiver": "receiver_address", "amount": "1.0", "memo": "test transaction" } body = json.dumps(data) signature = generate_sign(secret_key, timestamp, method, request_path, body=body) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase, "Content-Type": "application/json" } response = requests.post(base_url + request_path, data=body, headers=headers) > The above command returns JSON structured like this: json { "id": 0, "transaction_id": "string", "sender": "string", "receiver": "string", "amount": "string", "fee": "string", "timestamp": "string", "memo": "string", "status": "string" } This endpoint creates a new transaction from a specific wallet. #### HTTP Request `POST /v1/api/wallets/{wallet_id}/transactions` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID #### Request Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- receiver | string | Yes | Receiver address amount | string | Yes | Amount to send memo | string | No | Transaction memo #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Transaction ID transaction_id | string | Blockchain transaction ID sender | string | Sender address receiver | string | Receiver address amount | string | Transaction amount fee | string | Transaction fee timestamp | string | Transaction timestamp (ISO 8601) memo | string | Transaction memo status | string | Transaction status (pending, confirmed, failed) ### Get a Specific Transaction python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" wallet_id = "your_wallet_id" transaction_id = "transaction_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/wallets/{wallet_id}/transactions/{transaction_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": 0, "transaction_id": "string", "sender": "string", "receiver": "string", "amount": "string", "fee": "string", "timestamp": "string", "memo": "string", "status": "string" } This endpoint retrieves a specific transaction by its ID. #### HTTP Request `GET /v1/api/wallets/{wallet_id}/transactions/{transaction_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- wallet_id | string | Yes | Wallet ID transaction_id | string | Yes | Transaction ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Transaction ID transaction_id | string | Blockchain transaction ID sender | string | Sender address receiver | string | Receiver address amount | string | Transaction amount fee | string | Transaction fee timestamp | string | Transaction timestamp (ISO 8601) memo | string | Transaction memo status | string | Transaction status (pending, confirmed, failed) ## Coin ### Get All Coins python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/coins" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "name": "string", "symbol": "string", "address": "string", "decimals": 0, "type": "string", "website": "string", "explorer": "string", "status": "string", "price_usd": "string" } ] This endpoint retrieves all coins available on MINTme. #### HTTP Request `GET /v1/api/coins` #### Response Fields Field | Type | Description --------- | ------- | ----------- name | string | Coin name symbol | string | Coin symbol address | string | Coin contract address decimals | int | Number of decimals type | string | Coin type (token or coin) website | string | Coin website URL explorer | string | Blockchain explorer URL status | string | Coin status (active, inactive) price_usd | string | Current price in USD ### Get a Specific Coin python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" coin = "MINTME" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/coins/{coin}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "name": "string", "symbol": "string", "address": "string", "decimals": 0, "type": "string", "website": "string", "explorer": "string", "status": "string", "price_usd": "string" } This endpoint retrieves a specific coin by its symbol. #### HTTP Request `GET /v1/api/coins/{coin}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin symbol (e.g. "MINTME") #### Response Fields Field | Type | Description --------- | ------- | ----------- name | string | Coin name symbol | string | Coin symbol address | string | Coin contract address decimals | int | Number of decimals type | string | Coin type (token or coin) website | string | Coin website URL explorer | string | Blockchain explorer URL status | string | Coin status (active, inactive) price_usd | string | Current price in USD ### Get Coin Price History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" coin = "MINTME" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/coins/{coin}/price_history" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "timestamp": "string", "price": "string" } ] This endpoint retrieves price history for a specific coin. #### HTTP Request `GET /v1/api/coins/{coin}/price_history` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin symbol (e.g. "MINTME") #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- start | string | No | Start date (YYYY-MM-DD) end | string | No | End date (YYYY-MM-DD) interval | string | No | Time interval (daily, hourly, minute) #### Response Fields Field | Type | Description --------- | ------- | ----------- timestamp | string | Timestamp (ISO 8601) price | string | Price in USD at this timestamp ## Market ### Get Order Book python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" market = "MINTME_BTC" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/markets/{market}/orderbook" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "bids": [ [ "string", "string" ] ], "asks": [ [ "string", "string" ] ] } This endpoint retrieves the order book for a specific market. #### HTTP Request `GET /v1/api/markets/{market}/orderbook` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | Yes | Market symbol (e.g. "MINTME_BTC") #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- depth | int | No | Depth of order book to retrieve (default: 20) #### Response Fields Field | Type | Description --------- | ------- | ----------- bids | array | Array of bid orders [price, amount] asks | array | Array of ask orders [price, amount] ### Get Recent Trades python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" market = "MINTME_BTC" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/markets/{market}/trades" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": 0, "price": "string", "amount": "string", "total": "string", "side": "string", "timestamp": "string" } ] This endpoint retrieves recent trades for a specific market. #### HTTP Request `GET /v1/api/markets/{market}/trades` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | Yes | Market symbol (e.g. "MINTME_BTC") #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- limit | int | No | Number of trades to retrieve (default: 50, max: 100) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | int | Trade ID price | string | Trade price amount | string | Trade amount total | string | Total value (price * amount) side | string | Trade side (buy or sell) timestamp | string | Trade timestamp (ISO 8601) ### Get Market Summary python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" market = "MINTME_BTC" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/markets/{market}/summary" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "high": "string", "low": "string", "volume": "string", "last": "string", "change": "string", "timestamp": "string" } This endpoint retrieves summary statistics for a specific market. #### HTTP Request `GET /v1/api/markets/{market}/summary` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | Yes | Market symbol (e.g. "MINTME_BTC") #### Response Fields Field | Type | Description --------- | ------- | ----------- high | string | Highest price in last 24 hours low | string | Lowest price in last 24 hours volume | string | Total volume traded in last 24 hours last | string | Last traded price change | string | Percentage change in last 24 hours timestamp | string | Timestamp of last trade (ISO 8601) ### Get Market History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" market = "MINTME_BTC" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/markets/{market}/history" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "timestamp": "string", "open": "string", "high": "string", "low": "string", "close": "string", "volume": "string" } ] This endpoint retrieves historical data for a specific market. #### HTTP Request `GET /v1/api/markets/{market}/history` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | Yes | Market symbol (e.g. "MINTME_BTC") #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- start | string | No | Start date (YYYY-MM-DD) end | string | No | End date (YYYY-MM-DD) interval | string | No | Time interval (daily, hourly, minute) #### Response Fields Field | Type | Description --------- | ------- | ----------- timestamp | string | Timestamp (ISO 8601) open | string | Opening price high | string | Highest price low | string | Lowest price close | string | Closing price volume | string | Volume traded ## Order ### Get Open Orders python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/orders" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": "string", "market": "string", "type": "string", "side": "string", "price": "string", "amount": "string", "filled": "string", "remaining": "string", "status": "string", "timestamp": "string" } ] This endpoint retrieves all open orders. #### HTTP Request `GET /v1/api/orders` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | No | Filter orders by market (e.g. "MINTME_BTC") limit | int | No | Number of orders to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Order ID market | string | Market symbol type | string | Order type (limit, market) side | string | Order side (buy or sell) price | string | Order price amount | string | Order amount filled | string | Amount filled remaining | string | Amount remaining status | string | Order status (open, filled, canceled) timestamp | string | Order creation timestamp (ISO 8601) ### Create a New Order python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "POST" request_path = "/orders" data = { "market": "MINTME_BTC", "side": "buy", "type": "limit", "price": "0.000001", "amount": "100" } body = json.dumps(data) signature = generate_sign(secret_key, timestamp, method, request_path, body=body) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase, "Content-Type": "application/json" } response = requests.post(base_url + request_path, data=body, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "market": "string", "type": "string", "side": "string", "price": "string", "amount": "string", "filled": "string", "remaining": "string", "status": "string", "timestamp": "string" } This endpoint creates a new order. #### HTTP Request `POST /v1/api/orders` #### Request Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | Yes | Market symbol (e.g. "MINTME_BTC") side | string | Yes | Order side (buy or sell) type | string | Yes | Order type (limit or market) price | string | No | Price per unit (required for limit orders) amount | string | Yes | Amount to buy/sell client_id | string | No | Client order ID (optional) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Order ID market | string | Market symbol type | string | Order type side | string | Order side price | string | Order price amount | string | Order amount filled | string | Amount filled remaining | string | Amount remaining status | string | Order status timestamp | string | Order creation timestamp (ISO 8601) ### Get Order History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/orders/history" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": "string", "market": "string", "type": "string", "side": "string", "price": "string", "amount": "string", "filled": "string", "remaining": "string", "status": "string", "timestamp": "string", "updated_at": "string" } ] This endpoint retrieves order history. #### HTTP Request `GET /v1/api/orders/history` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | No | Filter orders by market (e.g. "MINTME_BTC") offset | int | No | Offset for pagination (default: 0) limit | int | No | Number of orders to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Order ID market | string | Market symbol type | string | Order type side | string | Order side price | string | Order price amount | string | Order amount filled | string | Amount filled remaining | string | Amount remaining status | string | Order status timestamp | string | Order creation timestamp (ISO 8601) updated_at | string | Last update timestamp (ISO 8601) ### Get a Specific Order python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" order_id = "order_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/orders/{order_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "market": "string", "type": "string", "side": "string", "price": "string", "amount": "string", "filled": "string", "remaining": "string", "status": "string", "timestamp": "string", "updated_at": "string" } This endpoint retrieves a specific order by its ID. #### HTTP Request `GET /v1/api/orders/{order_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- order_id | string | Yes | Order ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Order ID market | string | Market symbol type | string | Order type side | string | Order side price | string | Order price amount | string | Order amount filled | string | Amount filled remaining | string | Amount remaining status | string | Order status timestamp | string | Order creation timestamp (ISO 8601) updated_at | string | Last update timestamp (ISO 8601) ### Cancel an Order python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" order_id = "order_id" timestamp = int(time.time() * 1000) method = "DELETE" request_path = f"/orders/{order_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.delete(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "market": "string", "type": "string", "side": "string", "price": "string", "amount": "string", "filled": "string", "remaining": "string", "status": "string", "timestamp": "string", "updated_at": "string" } This endpoint cancels a specific order. #### HTTP Request `DELETE /v1/api/orders/{order_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- order_id | string | Yes | Order ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Order ID market | string | Market symbol type | string | Order type side | string | Order side price | string | Order price amount | string | Order amount filled | string | Amount filled remaining | string | Amount remaining status | string | Order status timestamp | string | Order creation timestamp (ISO 8601) updated_at | string | Last update timestamp (ISO 8601) ### Cancel All Orders python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "DELETE" request_path = "/orders" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.delete(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "message": "string" } This endpoint cancels all open orders. #### HTTP Request `DELETE /v1/api/orders` #### Response Fields Field | Type | Description --------- | ------- | ----------- message | string | Result message ## Trade ### Get Trade History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/trades" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": "string", "order_id": "string", "market": "string", "side": "string", "price": "string", "amount": "string", "total": "string", "fee": "string", "timestamp": "string" } ] This endpoint retrieves trade history. #### HTTP Request `GET /v1/api/trades` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- market | string | No | Filter trades by market (e.g. "MINTME_BTC") offset | int | No | Offset for pagination (default: 0) limit | int | No | Number of trades to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Trade ID order_id | string | Order ID associated with this trade market | string | Market symbol side | string | Trade side (buy or sell) price | string | Trade price amount | string | Trade amount total | string | Total value (price * amount) fee | string | Fee paid timestamp | string | Trade timestamp (ISO 8601) ### Get a Specific Trade python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" trade_id = "trade_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/trades/{trade_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "order_id": "string", "market": "string", "side": "string", "price": "string", "amount": "string", "total": "string", "fee": "string", "timestamp": "string" } This endpoint retrieves a specific trade by its ID. #### HTTP Request `GET /v1/api/trades/{trade_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- trade_id | string | Yes | Trade ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Trade ID order_id | string | Order ID associated with this trade market | string | Market symbol side | string | Trade side (buy or sell) price | string | Trade price amount | string | Trade amount total | string | Total value (price * amount) fee | string | Fee paid timestamp | string | Trade timestamp (ISO 8601) ## Deposit & Withdrawal ### Get Deposit Address python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" coin = "MINTME" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/deposits/{coin}/address" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "address": "string", "memo": "string" } This endpoint retrieves the deposit address for a specific coin. #### HTTP Request `GET /v1/api/deposits/{coin}/address` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin symbol (e.g. "MINTME") #### Response Fields Field | Type | Description --------- | ------- | ----------- address | string | Deposit address memo | string | Memo/tag for the deposit (if applicable) ### Get Deposit History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/deposits" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } ] This endpoint retrieves deposit history. #### HTTP Request `GET /v1/api/deposits` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | No | Filter deposits by coin (e.g. "MINTME") offset | int | No | Offset for pagination (default: 0) limit | int | No | Number of deposits to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Deposit ID coin | string | Coin symbol amount | string | Deposit amount address | string | Deposit address txid | string | Transaction ID status | string | Deposit status (pending, completed, failed) timestamp | string | Deposit timestamp (ISO 8601) ### Get a Specific Deposit python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" deposit_id = "deposit_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/deposits/{deposit_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } This endpoint retrieves a specific deposit by its ID. #### HTTP Request `GET /v1/api/deposits/{deposit_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- deposit_id | string | Yes | Deposit ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Deposit ID coin | string | Coin symbol amount | string | Deposit amount address | string | Deposit address txid | string | Transaction ID status | string | Deposit status timestamp | string | Deposit timestamp (ISO 8601) ### Create a Withdrawal python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "POST" request_path = "/withdrawals" data = { "coin": "MINTME", "address": "receiver_address", "amount": "1.0", "memo": "test withdrawal" } body = json.dumps(data) signature = generate_sign(secret_key, timestamp, method, request_path, body=body) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase, "Content-Type": "application/json" } response = requests.post(base_url + request_path, data=body, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } This endpoint creates a new withdrawal. #### HTTP Request `POST /v1/api/withdrawals` #### Request Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin symbol (e.g. "MINTME") address | string | Yes | Withdrawal address amount | string | Yes | Amount to withdraw memo | string | No | Memo/tag for the withdrawal (if applicable) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Withdrawal ID coin | string | Coin symbol amount | string | Withdrawal amount address | string | Withdrawal address txid | string | Transaction ID status | string | Withdrawal status (pending, processing, completed, failed) timestamp | string | Withdrawal timestamp (ISO 8601) ### Get Withdrawal History python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/withdrawals" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } ] This endpoint retrieves withdrawal history. #### HTTP Request `GET /v1/api/withdrawals` #### Query Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | No | Filter withdrawals by coin (e.g. "MINTME") offset | int | No | Offset for pagination (default: 0) limit | int | No | Number of withdrawals to retrieve (default: 10, max: 50) #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Withdrawal ID coin | string | Coin symbol amount | string | Withdrawal amount address | string | Withdrawal address txid | string | Transaction ID status | string | Withdrawal status timestamp | string | Withdrawal timestamp (ISO 8601) ### Get a Specific Withdrawal python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" withdrawal_id = "withdrawal_id" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/withdrawals/{withdrawal_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } This endpoint retrieves a specific withdrawal by its ID. #### HTTP Request `GET /v1/api/withdrawals/{withdrawal_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- withdrawal_id | string | Yes | Withdrawal ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Withdrawal ID coin | string | Coin symbol amount | string | Withdrawal amount address | string | Withdrawal address txid | string | Transaction ID status | string | Withdrawal status timestamp | string | Withdrawal timestamp (ISO 8601) ### Cancel a Withdrawal python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" withdrawal_id = "withdrawal_id" timestamp = int(time.time() * 1000) method = "DELETE" request_path = f"/withdrawals/{withdrawal_id}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.delete(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "id": "string", "coin": "string", "amount": "string", "address": "string", "txid": "string", "status": "string", "timestamp": "string" } This endpoint cancels a specific withdrawal (if it's still pending). #### HTTP Request `DELETE /v1/api/withdrawals/{withdrawal_id}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- withdrawal_id | string | Yes | Withdrawal ID #### Response Fields Field | Type | Description --------- | ------- | ----------- id | string | Withdrawal ID coin | string | Coin symbol amount | string | Withdrawal amount address | string | Withdrawal address txid | string | Transaction ID status | string | Withdrawal status timestamp | string | Withdrawal timestamp (ISO 8601) ## Account ### Get Account Information python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/account" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "email": "string", "username": "string", "tier": "string", "limits": { "withdrawal": { "daily": "string", "monthly": "string" }, "deposit": { "daily": "string", "monthly": "string" }, "trade": { "daily": "string", "monthly": "string" } }, "verification_level": "string", "kyc_status": "string" } This endpoint retrieves account information. #### HTTP Request `GET /v1/api/account` #### Response Fields Field | Type | Description --------- | ------- | ----------- email | string | Account email address username | string | Account username tier | string | Account tier level limits | object | Account limits verification_level | string | Verification level kyc_status | string | KYC status ### Get Account Balances python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/account/balances" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json [ { "coin": "string", "total": "string", "available": "string", "in_orders": "string" } ] This endpoint retrieves all account balances. #### HTTP Request `GET /v1/api/account/balances` #### Response Fields Field | Type | Description --------- | ------- | ----------- coin | string | Coin symbol total | string | Total balance available | string | Available balance (not locked in orders) in_orders | string | Balance locked in orders ### Get a Specific Account Balance python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" coin = "MINTME" timestamp = int(time.time() * 1000) method = "GET" request_path = f"/account/balances/{coin}" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "coin": "string", "total": "string", "available": "string", "in_orders": "string" } This endpoint retrieves a specific account balance by coin. #### HTTP Request `GET /v1/api/account/balances/{coin}` #### URL Parameters Parameter | Type | Required | Description --------- | ------- | ----------- | ----------- coin | string | Yes | Coin symbol (e.g. "MINTME") #### Response Fields Field | Type | Description --------- | ------- | ----------- coin | string | Coin symbol total | string | Total balance available | string | Available balance (not locked in orders) in_orders | string | Balance locked in orders ### Get Account Limits python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/account/limits" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "withdrawal": { "daily": "string", "monthly": "string" }, "deposit": { "daily": "string", "monthly": "string" }, "trade": { "daily": "string", "monthly": "string" } } This endpoint retrieves account limits. #### HTTP Request `GET /v1/api/account/limits` #### Response Fields Field | Type | Description --------- | ------- | ----------- withdrawal | object | Withdrawal limits deposit | object | Deposit limits trade | object | Trade limits ### Get API Key Information python import json import time import requests base_url = "https://www.mintme.com/v1/api" api_key = "Your API key" secret_key = "Your secret key" passphrase = "Your passphrase" timestamp = int(time.time() * 1000) method = "GET" request_path = "/account/api_key" signature = generate_sign(secret_key, timestamp, method, request_path, body=None) headers = { "X-MINTME-APIKEY": api_key, "X-MINTME-SIGN": signature, "X-MINTME-TIMESTAMP": str(timestamp), "X-MINTME-PASSPHRASE": passphrase } response = requests.get(base_url + request_path, headers=headers) > The above command returns JSON structured like this: json { "name": "string", "permissions": [ "string" ], "ip_restrictions": [ "string" ], "created_at": "string", "last_used": "string" } This endpoint retrieves information about the current API key. #### HTTP Request `GET /v1/api/account/api_key` #### Response Fields Field | Type | Description --------- | ------- | ----------- name | string | API key name permissions | array | List of permissions granted to this key ip_restrictions | array | List of IP restrictions created_at | string | Creation timestamp (ISO 8601) last_used | string | Last used timestamp (ISO 8601)">
Offer Click for best price

Best Price: $2600

Gammaretroviral Vector Market Size, Share 2025


MARKET INSIGHTS

Global gammaretroviral vector market was valued at USD 5.95 billion in 2024 and is projected to reach USD 16.66 billion by 2032, growing at a CAGR of 16.2% during the forecast period. This significant growth trajectory reflects the increasing adoption of viral vectors in gene therapy applications, particularly for treating genetic disorders and cancers.

Gammaretroviral vectors are engineered retroviral delivery systems derived from gammaretroviruses, which have proven particularly valuable for stable gene transfer applications. These vectors function by integrating their reverse-transcribed DNA into the host genome, enabling long-term transgene expression. Common examples include Moloney murine leukemia virus and feline leukemia virus vectors, which are widely used in research and clinical applications. The vectors' ability to efficiently transduce dividing cells makes them particularly suitable for ex vivo gene therapies targeting hematopoietic stem cells.

The market expansion is primarily driven by the rising prevalence of cancer and genetic diseases, coupled with advancements in gene therapy technologies. According to WHO data, cancer remains a leading cause of mortality worldwide, with increasing demand for innovative treatments. However, safety concerns regarding insertional mutagenesis and the emergence of alternative vector systems present challenges to market growth. Key players like Thermo Fisher Scientific, Oxford Biomedica, and Merck KGaA are actively developing improved vector systems to address these limitations while expanding their production capabilities.

MARKET DYNAMICS

MARKET DRIVERS

Rising Prevalence of Chronic Diseases to Accelerate Market Growth

The increasing global burden of chronic diseases, particularly cancer and genetic disorders, serves as a significant driver for the gammaretroviral vector market. Recent epidemiological data indicates approximately 19.3 million new cancer cases were diagnosed globally in 2023, with projections suggesting this number could rise by 47% by 2040. These vectors play a crucial role in developing advanced gene therapies for conditions like leukemia, lymphoma, and immunodeficiencies - diseases where conventional treatments often show limited efficacy. The therapeutic potential of gammaretroviral vectors in oncology is further amplified by their ability to stably integrate therapeutic genes into host genomes, offering long-term treatment benefits for patients.

Advancements in Gene Therapy Technologies to Fuel Adoption

Technological breakthroughs in viral vector engineering and gene delivery systems are revolutionizing the gammaretroviral vector landscape. Modern vector production platforms now achieve higher titers with improved safety profiles, addressing historical concerns about insertional mutagenesis. The recent development of self-inactivating (SIN) gammaretroviral vectors has significantly reduced the risk of oncogene activation, making them safer for clinical applications. This technological evolution coincides with increasing regulatory approvals for gene therapies, with over 20 cell and gene therapy products currently approved for various indications. As research institutions and biopharma companies continue refining vector design and manufacturing processes, these innovations are expected to drive mainstream adoption.

MARKET CHALLENGES

High Development Costs and Complex Manufacturing to Hinder Market Penetration

Despite their therapeutic potential, gammaretroviral vectors face significant manufacturing and commercialization challenges. Current Good Manufacturing Practice (cGMP)-compliant production requires specialized facilities and highly trained personnel, with production costs for viral vector-based therapies often exceeding $500,000 per patient dose. The complex bioprocessing involved – including upstream cell culture, vector harvesting, and downstream purification – presents numerous technical bottlenecks that impact yield and consistency. These cost barriers create substantial challenges for market penetration, particularly in developing regions with limited healthcare budgets.

Other Challenges

Safety Concerns

While modern SIN vectors have improved safety, residual concerns about insertional mutagenesis continue to impact clinical adoption. Stringent regulatory requirements for long-term safety monitoring add significant costs and complexity to clinical development programs.

Scalability Issues

Transitioning from small-scale research applications to commercial-scale production remains a persistent challenge, with many manufacturers struggling to maintain vector quality and consistency at larger production volumes.

MARKET RESTRAINTS

Regulatory Hurdles and Compliance Requirements to Limit Market Expansion

The gammaretroviral vector market faces substantial regulatory constraints that impact time-to-market and development costs. Regulatory agencies maintain rigorous standards for viral vector characterization, requiring comprehensive testing for replication competence, sterility, and potency. The average approval timeline for gene therapies using viral vectors currently exceeds 12-18 months, significantly longer than conventional biologics. Furthermore, regional variations in regulatory frameworks create additional complexity for manufacturers targeting global markets. These factors collectively restrain market growth by increasing development risks and inflating operational costs for industry participants.

MARKET OPPORTUNITIES

Expansion in Rare Disease Therapeutics to Unlock Growth Potential

The growing focus on orphan drug development presents significant opportunities for gammaretroviral vector applications. With over 7,000 identified rare diseases – 95% of which currently lack FDA-approved treatments – the potential addressable market for gene therapies continues to expand rapidly. Recent regulatory incentives, including orphan drug designations and accelerated approval pathways, have spurred investment in rare disease gene therapies. Gammaretroviral vectors offer particular advantages for certain hematopoietic and metabolic disorders where stable genomic integration provides durable therapeutic effects. As genetic screening becomes more widespread and precision medicine advances, this therapeutic area represents a high-growth segment for market players.

Emerging Markets to Offer Untapped Potential

Developing economies present substantial growth opportunities as healthcare infrastructure improves and regulatory systems mature. Many Asian countries have implemented expedited approval pathways for advanced therapies, with China's gene therapy market projected to grow at over 25% CAGR through 2030. Local manufacturing partnerships and technology transfer agreements are helping overcome traditional barriers to market entry. While challenges remain in pricing and reimbursement, the growing middle-class population and increasing healthcare expenditure in these regions position them as key future markets for gammaretroviral vector-based therapies.

Segment Analysis:

By Type

Lentiviral Vectors Lead the Market Due to High Efficiency in Gene Delivery

The market is segmented based on type into:

  • Lentiviral vectors

    • Subtypes: HIV-1, HIV-2, SIV, and others

  • Adenoviral vectors

  • Adeno-associated viral vectors

    • Subtypes: AAV1, AAV2, AAV5, and others

  • Other retroviral vectors

By Application

Gene Therapy Dominates Due to Rising Demand for Genetic Disorder Treatments

The market is segmented based on application into:

  • Gene therapy

  • Vaccinology

  • Cell therapy

  • Cancer research

  • Others

By End User

Biotechnology and Pharmaceutical Companies Hold Largest Market Share

The market is segmented based on end user into:

  • Biotechnology companies

  • Pharmaceutical companies

  • Research institutions

  • Hospitals and clinics

By Disease Type

Oncology Applications Drive Significant Market Growth

The market is segmented based on disease type into:

  • Oncology

  • Genetic disorders

  • Infectious diseases

  • Neurological disorders

  • Others

COMPETITIVE LANDSCAPE

Key Industry Players

Strategic Expansion and Innovations Drive Market Competition

The global gammaretroviral vector market features a dynamic mix of established biotech firms and emerging biopharmaceutical companies competing for dominance. Thermo Fisher Scientific Inc. leads the segment with its comprehensive suite of gene therapy solutions, accounting for approximately 18% of the market share in 2024. Their position is reinforced by strategic acquisitions, including the 2023 purchase of a viral vector manufacturing facility in Massachusetts to expand production capacity.

Oxford Biomedica and Merck KGaA have emerged as key contenders, leveraging their expertise in lentiviral vector development to capture nearly 12% and 15% of the market respectively. Both companies recently announced collaborative agreements with major pharmaceutical firms to develop next-generation gammaretroviral vectors for oncology applications, signaling intensified R&D efforts in this space.

The competitive environment is further shaped by regional specialization. While North American players dominate in production scale, European firms like UniQure N.V. are making strides in clinical-grade vector manufacturing, particularly for rare disease treatments. Meanwhile, Asian manufacturers such as Takara Bio Inc. are gaining traction through cost-efficient production models and government-backed genomic medicine initiatives.

Recent industry developments have underscored the importance of vertical integration, with multiple competitors expanding into full-service viral vector CDMO operations. Charles River Laboratories notably enhanced its gene therapy capabilities through the 2023 acquisition of Vigene Biosciences, positioning itself as an end-to-end solutions provider in the gammaretroviral vector value chain.

List of Prominent Gammaretroviral Vector Manufacturers

  • Thermo Fisher Scientific Inc. (U.S.)
  • Oxford Biomedica (U.K.)
  • Merck KGaA (Germany)
  • Charles River Laboratories (U.S.)
  • UniQure N.V. (Netherlands)
  • Fujifilm Corporation (Japan)
  • Takara Bio Inc. (Japan)
  • Spark Therapeutics Inc. (U.S.)
  • Boehringer Ingelheim International GmbH (Germany)
  • Genezen (U.S.)
  • Brammer Bio (U.S.)
  • Waisman Biomanufacturing (U.S.)
  • Aldevron (U.S.)

GAMMARETROVIRAL VECTOR MARKET TRENDS

Rising Demand for Gene Therapies to Drive Gammaretroviral Vector Market Growth

The global gammaretroviral vector market is witnessing significant expansion, driven primarily by the increasing adoption of gene therapies for treating genetic disorders and cancers. Gammaretroviral vectors, known for their stable genomic integration and efficient gene delivery, are becoming pivotal tools in advanced therapeutic development. Recent clinical successes in using these vectors for conditions like severe combined immunodeficiency (SCID) and certain hematologic malignancies have validated their therapeutic potential. Currently, over 2,000 gene therapy clinical trials are underway globally, with gammaretroviral vectors playing a crucial role in approximately 15% of these studies. The market is further benefiting from improved vector safety profiles through enhanced engineering techniques that reduce insertional mutagenesis risks.

Other Trends

Technological Advancements in Vector Production

Progress in biomanufacturing technologies is enabling more efficient and scalable production of gammaretroviral vectors, addressing previous limitations of low titers and production consistency. The introduction of suspension cell culture systems has increased vector yields by up to 10-fold compared to traditional adherent culture methods. Furthermore, the implementation of automated closed-system manufacturing platforms is improving product consistency while reducing contamination risks - critical factors as therapies move toward commercial-scale production. These advancements are particularly significant as the industry works to meet the projected market need for over 50 million vector doses annually by 2030 for gene therapy applications alone.

Expanding Applications in Oncology and Infectious Disease Prevention

While oncology remains the dominant application area, accounting for nearly 45% of current gammaretroviral vector use, emerging applications in infectious disease prevention are creating new growth opportunities. The technology's proven ability to engineer durable immune responses is being leveraged in next-generation vaccine development, particularly for complex pathogens like HIV and hepatitis C. Meanwhile, in cancer treatment, novel vector designs are enhancing the efficacy of CAR-T cell therapies, with recent clinical data showing response rates exceeding 80% in certain hematologic cancers. The versatility of these vectors is also being demonstrated in rare disease treatments, where they enable permanent correction of genetic defects with single-dose therapies. This broadening application spectrum is attracting significant investment, with venture funding for gene therapy platforms increasing by 150% since 2020.

Regional Analysis: Gammaretroviral Vector Market

North America

The North American gammaretroviral vector market is characterized by strong biopharmaceutical R&D investments, advanced gene therapy research, and a well-established regulatory framework. The U.S. dominates with over 45% of global biotechnology funding, driving demand for viral vector-based therapies. FDA approvals for gene therapies, such as those targeting hematologic malignancies, have accelerated adoption. However, stringent regulatory requirements and high production costs pose challenges. Leading companies like Thermo Fisher Scientific and Charles River Laboratories actively expand viral vector manufacturing capacities to meet rising demand from academic and commercial research.

Europe

Europe's market benefits from harmonized EMA regulations supporting gene therapy development and robust government funding for rare disease research. Countries like Germany and the U.K. lead in clinical trials utilizing gammaretroviral vectors, particularly for oncology and immunology applications. Collaborations between academia and industry, such as Oxford Biomedica's partnerships with global pharma firms, strengthen the ecosystem. However, complex reimbursement policies and ethical concerns regarding gene-modified therapies occasionally slow commercialization. The region maintains competitiveness through GMP-compliant manufacturing innovations and a growing pipeline of CAR-T cell therapies.

Asia-Pacific

APAC exhibits the highest growth potential, fueled by expanding biotechnology sectors in China and India, increasing cancer prevalence, and government initiatives like China’s 14th Five-Year Plan prioritizing gene therapy infrastructure. Japan’s PMDA has adopted accelerated approvals for advanced therapies, benefiting domestic players like Fujifilm. While cost-effective manufacturing drives outsourcing to this region, inconsistent IP protection and limited local expertise in large-scale vector production restrain market maturity. Partnerships with Western firms aim to bridge this gap South Korea’s cell therapy hubs, for instance, attract significant foreign investment.

South America

Market traction is emerging gradually, with Brazil and Argentina piloting gene therapy initiatives through academic collaborations. Political-economic instability and underdeveloped regulatory pathways hinder large-scale adoption, though increasing clinical trial activities signal future potential. Local production remains minimal due to reliance on imported vectors and limited funding only 3-5% of regional healthcare budgets target biotech development. Nonetheless, rising chronic disease burdens and improving hospital infrastructure could stimulate demand over the next decade.

Middle East & Africa

The MEA market is nascent but evolving, with Israel and UAE spearheading regional biotech hubs through tax incentives and research grants. Saudi Arabia’s Vision 2030 includes genomics as a priority, though most vector supplies are imported from Europe or North America. Challenges include scarce cold-chain logistics and low patient affordability for advanced therapies. Strategic partnerships, such as those between Turkish universities and EU research consortia, aim to build localized capabilities. Long-term growth will depend on healthcare modernization and regulatory alignment with international standards.

Report Scope

This market research report offers a holistic overview of global and regional markets for the forecast period 2025–2032. It presents accurate and actionable insights based on a blend of primary and secondary research.

Key Coverage Areas:

  • Market Overview

    • Global and regional market size (historical & forecast)

    • Growth trends and value/volume projections

  • Segmentation Analysis

    • By product type or category

    • By application or usage area

    • By end-user industry

    • By distribution channel (if applicable)

  • Regional Insights

    • North America, Europe, Asia-Pacific, Latin America, Middle East & Africa

    • Country-level data for key markets

  • Competitive Landscape

    • Company profiles and market share analysis

    • Key strategies: M&A, partnerships, expansions

    • Product portfolio and pricing strategies

  • Technology & Innovation

    • Emerging technologies and R&D trends

    • Automation, digitalization, sustainability initiatives

    • Impact of AI, IoT, or other disruptors (where applicable)

  • Market Dynamics

    • Key drivers supporting market growth

    • Restraints and potential risk factors

    • Supply chain trends and challenges

  • Opportunities & Recommendations

    • High-growth segments

    • Investment hotspots

    • Strategic suggestions for stakeholders

  • Stakeholder Insights

    • Target audience includes manufacturers, suppliers, distributors, investors, regulators, and policymakers

FREQUENTLY ASKED QUESTIONS:

What is the current market size of Global Gammaretroviral Vector Market?

-> The global gammaretroviral vector market was valued at USD 5,948 million in 2024 and is projected to reach USD 16,660 million by 2032, growing at a CAGR of 16.2% during the forecast period.

Which key companies operate in Global Gammaretroviral Vector Market?

-> Key players include Thermo Fisher Scientific Inc., Merck KGaA, Oxford Biomedica, Charles River Laboratories, Fujifilm Corporation, and Pfizer Inc., among others.

What are the key growth drivers?

-> Key growth drivers include rising prevalence of cancer and genetic disorders, increasing demand for gene therapy, and advancements in viral vector technologies.

Which region dominates the market?

-> North America holds the largest market share, while Asia-Pacific is expected to witness the highest growth rate during the forecast period.

What are the emerging trends?

-> Emerging trends include development of safer viral vectors, increasing investments in cell and gene therapy research, and expansion of manufacturing capabilities.

Report Attributes Report Details
Report Title Gammaretroviral Vector Market, Global Outlook and Forecast 2025-2032
Historical Year 2018 to 2022 (Data from 2010 can be provided as per availability)
Base Year 2024
Forecast Year 2032
Number of Pages 148 Pages
Customization Available Yes, the report can be customized as per your need.

TABLE OF CONTENTS

1 Introduction to Research & Analysis Reports
1.1 Gammaretroviral Vector Market Definition
1.2 Market Segments
1.2.1 Segment by Type
1.2.2 Segment by Application
1.3 Global Gammaretroviral Vector Market Overview
1.4 Features & Benefits of This Report
1.5 Methodology & Sources of Information
1.5.1 Research Methodology
1.5.2 Research Process
1.5.3 Base Year
1.5.4 Report Assumptions & Caveats
2 Global Gammaretroviral Vector Overall Market Size
2.1 Global Gammaretroviral Vector Market Size: 2024 VS 2032
2.2 Global Gammaretroviral Vector Market Size, Prospects & Forecasts: 2020-2032
2.3 Global Gammaretroviral Vector Sales: 2020-2032
3 Company Landscape
3.1 Top Gammaretroviral Vector Players in Global Market
3.2 Top Global Gammaretroviral Vector Companies Ranked by Revenue
3.3 Global Gammaretroviral Vector Revenue by Companies
3.4 Global Gammaretroviral Vector Sales by Companies
3.5 Global Gammaretroviral Vector Price by Manufacturer (2020-2025)
3.6 Top 3 and Top 5 Gammaretroviral Vector Companies in Global Market, by Revenue in 2024
3.7 Global Manufacturers Gammaretroviral Vector Product Type
3.8 Tier 1, Tier 2, and Tier 3 Gammaretroviral Vector Players in Global Market
3.8.1 List of Global Tier 1 Gammaretroviral Vector Companies
3.8.2 List of Global Tier 2 and Tier 3 Gammaretroviral Vector Companies
4 Sights by Product
4.1 Overview
4.1.1 Segment by Type - Global Gammaretroviral Vector Market Size Markets, 2024 & 2032
4.1.2 Lentiviral Vectors
4.1.3 Adenoviral Vectors
4.1.4 Adeno-Associated Viral Vectors
4.1.5 Other
4.2 Segment by Type - Global Gammaretroviral Vector Revenue & Forecasts
4.2.1 Segment by Type - Global Gammaretroviral Vector Revenue, 2020-2025
4.2.2 Segment by Type - Global Gammaretroviral Vector Revenue, 2026-2032
4.2.3 Segment by Type - Global Gammaretroviral Vector Revenue Market Share, 2020-2032
4.3 Segment by Type - Global Gammaretroviral Vector Sales & Forecasts
4.3.1 Segment by Type - Global Gammaretroviral Vector Sales, 2020-2025
4.3.2 Segment by Type - Global Gammaretroviral Vector Sales, 2026-2032
4.3.3 Segment by Type - Global Gammaretroviral Vector Sales Market Share, 2020-2032
4.4 Segment by Type - Global Gammaretroviral Vector Price (Manufacturers Selling Prices), 2020-2032
5 Sights by Application
5.1 Overview
5.1.1 Segment by Application - Global Gammaretroviral Vector Market Size, 2024 & 2032
5.1.2 Gene Therapy
5.1.3 Vaccinology
5.1.4 Other
5.2 Segment by Application - Global Gammaretroviral Vector Revenue & Forecasts
5.2.1 Segment by Application - Global Gammaretroviral Vector Revenue, 2020-2025
5.2.2 Segment by Application - Global Gammaretroviral Vector Revenue, 2026-2032
5.2.3 Segment by Application - Global Gammaretroviral Vector Revenue Market Share, 2020-2032
5.3 Segment by Application - Global Gammaretroviral Vector Sales & Forecasts
5.3.1 Segment by Application - Global Gammaretroviral Vector Sales, 2020-2025
5.3.2 Segment by Application - Global Gammaretroviral Vector Sales, 2026-2032
5.3.3 Segment by Application - Global Gammaretroviral Vector Sales Market Share, 2020-2032
5.4 Segment by Application - Global Gammaretroviral Vector Price (Manufacturers Selling Prices), 2020-2032
6 Sights by Region
6.1 By Region - Global Gammaretroviral Vector Market Size, 2024 & 2032
6.2 By Region - Global Gammaretroviral Vector Revenue & Forecasts
6.2.1 By Region - Global Gammaretroviral Vector Revenue, 2020-2025
6.2.2 By Region - Global Gammaretroviral Vector Revenue, 2026-2032
6.2.3 By Region - Global Gammaretroviral Vector Revenue Market Share, 2020-2032
6.3 By Region - Global Gammaretroviral Vector Sales & Forecasts
6.3.1 By Region - Global Gammaretroviral Vector Sales, 2020-2025
6.3.2 By Region - Global Gammaretroviral Vector Sales, 2026-2032
6.3.3 By Region - Global Gammaretroviral Vector Sales Market Share, 2020-2032
6.4 North America
6.4.1 By Country - North America Gammaretroviral Vector Revenue, 2020-2032
6.4.2 By Country - North America Gammaretroviral Vector Sales, 2020-2032
6.4.3 United States Gammaretroviral Vector Market Size, 2020-2032
6.4.4 Canada Gammaretroviral Vector Market Size, 2020-2032
6.4.5 Mexico Gammaretroviral Vector Market Size, 2020-2032
6.5 Europe
6.5.1 By Country - Europe Gammaretroviral Vector Revenue, 2020-2032
6.5.2 By Country - Europe Gammaretroviral Vector Sales, 2020-2032
6.5.3 Germany Gammaretroviral Vector Market Size, 2020-2032
6.5.4 France Gammaretroviral Vector Market Size, 2020-2032
6.5.5 U.K. Gammaretroviral Vector Market Size, 2020-2032
6.5.6 Italy Gammaretroviral Vector Market Size, 2020-2032
6.5.7 Russia Gammaretroviral Vector Market Size, 2020-2032
6.5.8 Nordic Countries Gammaretroviral Vector Market Size, 2020-2032
6.5.9 Benelux Gammaretroviral Vector Market Size, 2020-2032
6.6 Asia
6.6.1 By Region - Asia Gammaretroviral Vector Revenue, 2020-2032
6.6.2 By Region - Asia Gammaretroviral Vector Sales, 2020-2032
6.6.3 China Gammaretroviral Vector Market Size, 2020-2032
6.6.4 Japan Gammaretroviral Vector Market Size, 2020-2032
6.6.5 South Korea Gammaretroviral Vector Market Size, 2020-2032
6.6.6 Southeast Asia Gammaretroviral Vector Market Size, 2020-2032
6.6.7 India Gammaretroviral Vector Market Size, 2020-2032
6.7 South America
6.7.1 By Country - South America Gammaretroviral Vector Revenue, 2020-2032
6.7.2 By Country - South America Gammaretroviral Vector Sales, 2020-2032
6.7.3 Brazil Gammaretroviral Vector Market Size, 2020-2032
6.7.4 Argentina Gammaretroviral Vector Market Size, 2020-2032
6.8 Middle East & Africa
6.8.1 By Country - Middle East & Africa Gammaretroviral Vector Revenue, 2020-2032
6.8.2 By Country - Middle East & Africa Gammaretroviral Vector Sales, 2020-2032
6.8.3 Turkey Gammaretroviral Vector Market Size, 2020-2032
6.8.4 Israel Gammaretroviral Vector Market Size, 2020-2032
6.8.5 Saudi Arabia Gammaretroviral Vector Market Size, 2020-2032
6.8.6 UAE Gammaretroviral Vector Market Size, 2020-2032
7 Manufacturers & Brands Profiles
7.1 Novasep
7.1.1 Novasep Company Summary
7.1.2 Novasep Business Overview
7.1.3 Novasep Gammaretroviral Vector Major Product Offerings
7.1.4 Novasep Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.1.5 Novasep Key News & Latest Developments
7.2 MerckKGaA
7.2.1 MerckKGaA Company Summary
7.2.2 MerckKGaA Business Overview
7.2.3 MerckKGaA Gammaretroviral Vector Major Product Offerings
7.2.4 MerckKGaA Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.2.5 MerckKGaA Key News & Latest Developments
7.3 Charles River Laboratories
7.3.1 Charles River Laboratories Company Summary
7.3.2 Charles River Laboratories Business Overview
7.3.3 Charles River Laboratories Gammaretroviral Vector Major Product Offerings
7.3.4 Charles River Laboratories Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.3.5 Charles River Laboratories Key News & Latest Developments
7.4 UniQure N.V.
7.4.1 UniQure N.V. Company Summary
7.4.2 UniQure N.V. Business Overview
7.4.3 UniQure N.V. Gammaretroviral Vector Major Product Offerings
7.4.4 UniQure N.V. Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.4.5 UniQure N.V. Key News & Latest Developments
7.5 Waisman Biomanufacturing
7.5.1 Waisman Biomanufacturing Company Summary
7.5.2 Waisman Biomanufacturing Business Overview
7.5.3 Waisman Biomanufacturing Gammaretroviral Vector Major Product Offerings
7.5.4 Waisman Biomanufacturing Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.5.5 Waisman Biomanufacturing Key News & Latest Developments
7.6 Creative-Biogene
7.6.1 Creative-Biogene Company Summary
7.6.2 Creative-Biogene Business Overview
7.6.3 Creative-Biogene Gammaretroviral Vector Major Product Offerings
7.6.4 Creative-Biogene Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.6.5 Creative-Biogene Key News & Latest Developments
7.7 Aldevron
7.7.1 Aldevron Company Summary
7.7.2 Aldevron Business Overview
7.7.3 Aldevron Gammaretroviral Vector Major Product Offerings
7.7.4 Aldevron Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.7.5 Aldevron Key News & Latest Developments
7.8 Addgene
7.8.1 Addgene Company Summary
7.8.2 Addgene Business Overview
7.8.3 Addgene Gammaretroviral Vector Major Product Offerings
7.8.4 Addgene Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.8.5 Addgene Key News & Latest Developments
7.9 Oxford Biomedica
7.9.1 Oxford Biomedica Company Summary
7.9.2 Oxford Biomedica Business Overview
7.9.3 Oxford Biomedica Gammaretroviral Vector Major Product Offerings
7.9.4 Oxford Biomedica Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.9.5 Oxford Biomedica Key News & Latest Developments
7.10 Thermo Fisher Scientific Inc.
7.10.1 Thermo Fisher Scientific Inc. Company Summary
7.10.2 Thermo Fisher Scientific Inc. Business Overview
7.10.3 Thermo Fisher Scientific Inc. Gammaretroviral Vector Major Product Offerings
7.10.4 Thermo Fisher Scientific Inc. Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.10.5 Thermo Fisher Scientific Inc. Key News & Latest Developments
7.11 Fujifilm Corporation
7.11.1 Fujifilm Corporation Company Summary
7.11.2 Fujifilm Corporation Business Overview
7.11.3 Fujifilm Corporation Gammaretroviral Vector Major Product Offerings
7.11.4 Fujifilm Corporation Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.11.5 Fujifilm Corporation Key News & Latest Developments
7.12 Spark Therapeutics Inc
7.12.1 Spark Therapeutics Inc Company Summary
7.12.2 Spark Therapeutics Inc Business Overview
7.12.3 Spark Therapeutics Inc Gammaretroviral Vector Major Product Offerings
7.12.4 Spark Therapeutics Inc Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.12.5 Spark Therapeutics Inc Key News & Latest Developments
7.13 ABL Inc
7.13.1 ABL Inc Company Summary
7.13.2 ABL Inc Business Overview
7.13.3 ABL Inc Gammaretroviral Vector Major Product Offerings
7.13.4 ABL Inc Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.13.5 ABL Inc Key News & Latest Developments
7.14 Boehringer Ingelheim International GmbH
7.14.1 Boehringer Ingelheim International GmbH Company Summary
7.14.2 Boehringer Ingelheim International GmbH Business Overview
7.14.3 Boehringer Ingelheim International GmbH Gammaretroviral Vector Major Product Offerings
7.14.4 Boehringer Ingelheim International GmbH Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.14.5 Boehringer Ingelheim International GmbH Key News & Latest Developments
7.15 Brammer Bio
7.15.1 Brammer Bio Company Summary
7.15.2 Brammer Bio Business Overview
7.15.3 Brammer Bio Gammaretroviral Vector Major Product Offerings
7.15.4 Brammer Bio Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.15.5 Brammer Bio Key News & Latest Developments
7.16 Creative Biogene
7.16.1 Creative Biogene Company Summary
7.16.2 Creative Biogene Business Overview
7.16.3 Creative Biogene Gammaretroviral Vector Major Product Offerings
7.16.4 Creative Biogene Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.16.5 Creative Biogene Key News & Latest Developments
7.17 General Electric
7.17.1 General Electric Company Summary
7.17.2 General Electric Business Overview
7.17.3 General Electric Gammaretroviral Vector Major Product Offerings
7.17.4 General Electric Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.17.5 General Electric Key News & Latest Developments
7.18 Pfizer Inc
7.18.1 Pfizer Inc Company Summary
7.18.2 Pfizer Inc Business Overview
7.18.3 Pfizer Inc Gammaretroviral Vector Major Product Offerings
7.18.4 Pfizer Inc Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.18.5 Pfizer Inc Key News & Latest Developments
7.19 Genezen
7.19.1 Genezen Company Summary
7.19.2 Genezen Business Overview
7.19.3 Genezen Gammaretroviral Vector Major Product Offerings
7.19.4 Genezen Gammaretroviral Vector Sales and Revenue in Global (2020-2025)
7.19.5 Genezen Key News & Latest Developments
8 Global Gammaretroviral Vector Production Capacity, Analysis
8.1 Global Gammaretroviral Vector Production Capacity, 2020-2032
8.2 Gammaretroviral Vector Production Capacity of Key Manufacturers in Global Market
8.3 Global Gammaretroviral Vector Production by Region
9 Key Market Trends, Opportunity, Drivers and Restraints
9.1 Market Opportunities & Trends
9.2 Market Drivers
9.3 Market Restraints
10 Gammaretroviral Vector Supply Chain Analysis
10.1 Gammaretroviral Vector Industry Value Chain
10.2 Gammaretroviral Vector Upstream Market
10.3 Gammaretroviral Vector Downstream and Clients
10.4 Marketing Channels Analysis
10.4.1 Marketing Channels
10.4.2 Gammaretroviral Vector Distributors and Sales Agents in Global
11 Conclusion
12 Appendix
12.1 Note
12.2 Examples of Clients
12.3 Disclaimer

LIST OF TABLES & FIGURES

List of Tables
Table 1. Key Players of Gammaretroviral Vector in Global Market
Table 2. Top Gammaretroviral Vector Players in Global Market, Ranking by Revenue (2024)
Table 3. Global Gammaretroviral Vector Revenue by Companies, (US$, Mn), 2020-2025
Table 4. Global Gammaretroviral Vector Revenue Share by Companies, 2020-2025
Table 5. Global Gammaretroviral Vector Sales by Companies, (K Units), 2020-2025
Table 6. Global Gammaretroviral Vector Sales Share by Companies, 2020-2025
Table 7. Key Manufacturers Gammaretroviral Vector Price (2020-2025) & (US$/Unit)
Table 8. Global Manufacturers Gammaretroviral Vector Product Type
Table 9. List of Global Tier 1 Gammaretroviral Vector Companies, Revenue (US$, Mn) in 2024 and Market Share
Table 10. List of Global Tier 2 and Tier 3 Gammaretroviral Vector Companies, Revenue (US$, Mn) in 2024 and Market Share
Table 11. Segment by Type � Global Gammaretroviral Vector Revenue, (US$, Mn), 2024 & 2032
Table 12. Segment by Type - Global Gammaretroviral Vector Revenue (US$, Mn), 2020-2025
Table 13. Segment by Type - Global Gammaretroviral Vector Revenue (US$, Mn), 2026-2032
Table 14. Segment by Type - Global Gammaretroviral Vector Sales (K Units), 2020-2025
Table 15. Segment by Type - Global Gammaretroviral Vector Sales (K Units), 2026-2032
Table 16. Segment by Application � Global Gammaretroviral Vector Revenue, (US$, Mn), 2024 & 2032
Table 17. Segment by Application - Global Gammaretroviral Vector Revenue, (US$, Mn), 2020-2025
Table 18. Segment by Application - Global Gammaretroviral Vector Revenue, (US$, Mn), 2026-2032
Table 19. Segment by Application - Global Gammaretroviral Vector Sales, (K Units), 2020-2025
Table 20. Segment by Application - Global Gammaretroviral Vector Sales, (K Units), 2026-2032
Table 21. By Region � Global Gammaretroviral Vector Revenue, (US$, Mn), 2025-2032
Table 22. By Region - Global Gammaretroviral Vector Revenue, (US$, Mn), 2020-2025
Table 23. By Region - Global Gammaretroviral Vector Revenue, (US$, Mn), 2026-2032
Table 24. By Region - Global Gammaretroviral Vector Sales, (K Units), 2020-2025
Table 25. By Region - Global Gammaretroviral Vector Sales, (K Units), 2026-2032
Table 26. By Country - North America Gammaretroviral Vector Revenue, (US$, Mn), 2020-2025
Table 27. By Country - North America Gammaretroviral Vector Revenue, (US$, Mn), 2026-2032
Table 28. By Country - North America Gammaretroviral Vector Sales, (K Units), 2020-2025
Table 29. By Country - North America Gammaretroviral Vector Sales, (K Units), 2026-2032
Table 30. By Country - Europe Gammaretroviral Vector Revenue, (US$, Mn), 2020-2025
Table 31. By Country - Europe Gammaretroviral Vector Revenue, (US$, Mn), 2026-2032
Table 32. By Country - Europe Gammaretroviral Vector Sales, (K Units), 2020-2025
Table 33. By Country - Europe Gammaretroviral Vector Sales, (K Units), 2026-2032
Table 34. By Region - Asia Gammaretroviral Vector Revenue, (US$, Mn), 2020-2025
Table 35. By Region - Asia Gammaretroviral Vector Revenue, (US$, Mn), 2026-2032
Table 36. By Region - Asia Gammaretroviral Vector Sales, (K Units), 2020-2025
Table 37. By Region - Asia Gammaretroviral Vector Sales, (K Units), 2026-2032
Table 38. By Country - South America Gammaretroviral Vector Revenue, (US$, Mn), 2020-2025
Table 39. By Country - South America Gammaretroviral Vector Revenue, (US$, Mn), 2026-2032
Table 40. By Country - South America Gammaretroviral Vector Sales, (K Units), 2020-2025
Table 41. By Country - South America Gammaretroviral Vector Sales, (K Units), 2026-2032
Table 42. By Country - Middle East & Africa Gammaretroviral Vector Revenue, (US$, Mn), 2020-2025
Table 43. By Country - Middle East & Africa Gammaretroviral Vector Revenue, (US$, Mn), 2026-2032
Table 44. By Country - Middle East & Africa Gammaretroviral Vector Sales, (K Units), 2020-2025
Table 45. By Country - Middle East & Africa Gammaretroviral Vector Sales, (K Units), 2026-2032
Table 46. Novasep Company Summary
Table 47. Novasep Gammaretroviral Vector Product Offerings
Table 48. Novasep Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 49. Novasep Key News & Latest Developments
Table 50. MerckKGaA Company Summary
Table 51. MerckKGaA Gammaretroviral Vector Product Offerings
Table 52. MerckKGaA Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 53. MerckKGaA Key News & Latest Developments
Table 54. Charles River Laboratories Company Summary
Table 55. Charles River Laboratories Gammaretroviral Vector Product Offerings
Table 56. Charles River Laboratories Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 57. Charles River Laboratories Key News & Latest Developments
Table 58. UniQure N.V. Company Summary
Table 59. UniQure N.V. Gammaretroviral Vector Product Offerings
Table 60. UniQure N.V. Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 61. UniQure N.V. Key News & Latest Developments
Table 62. Waisman Biomanufacturing Company Summary
Table 63. Waisman Biomanufacturing Gammaretroviral Vector Product Offerings
Table 64. Waisman Biomanufacturing Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 65. Waisman Biomanufacturing Key News & Latest Developments
Table 66. Creative-Biogene Company Summary
Table 67. Creative-Biogene Gammaretroviral Vector Product Offerings
Table 68. Creative-Biogene Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 69. Creative-Biogene Key News & Latest Developments
Table 70. Aldevron Company Summary
Table 71. Aldevron Gammaretroviral Vector Product Offerings
Table 72. Aldevron Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 73. Aldevron Key News & Latest Developments
Table 74. Addgene Company Summary
Table 75. Addgene Gammaretroviral Vector Product Offerings
Table 76. Addgene Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 77. Addgene Key News & Latest Developments
Table 78. Oxford Biomedica Company Summary
Table 79. Oxford Biomedica Gammaretroviral Vector Product Offerings
Table 80. Oxford Biomedica Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 81. Oxford Biomedica Key News & Latest Developments
Table 82. Thermo Fisher Scientific Inc. Company Summary
Table 83. Thermo Fisher Scientific Inc. Gammaretroviral Vector Product Offerings
Table 84. Thermo Fisher Scientific Inc. Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 85. Thermo Fisher Scientific Inc. Key News & Latest Developments
Table 86. Fujifilm Corporation Company Summary
Table 87. Fujifilm Corporation Gammaretroviral Vector Product Offerings
Table 88. Fujifilm Corporation Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 89. Fujifilm Corporation Key News & Latest Developments
Table 90. Spark Therapeutics Inc Company Summary
Table 91. Spark Therapeutics Inc Gammaretroviral Vector Product Offerings
Table 92. Spark Therapeutics Inc Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 93. Spark Therapeutics Inc Key News & Latest Developments
Table 94. ABL Inc Company Summary
Table 95. ABL Inc Gammaretroviral Vector Product Offerings
Table 96. ABL Inc Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 97. ABL Inc Key News & Latest Developments
Table 98. Boehringer Ingelheim International GmbH Company Summary
Table 99. Boehringer Ingelheim International GmbH Gammaretroviral Vector Product Offerings
Table 100. Boehringer Ingelheim International GmbH Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 101. Boehringer Ingelheim International GmbH Key News & Latest Developments
Table 102. Brammer Bio Company Summary
Table 103. Brammer Bio Gammaretroviral Vector Product Offerings
Table 104. Brammer Bio Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 105. Brammer Bio Key News & Latest Developments
Table 106. Creative Biogene Company Summary
Table 107. Creative Biogene Gammaretroviral Vector Product Offerings
Table 108. Creative Biogene Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 109. Creative Biogene Key News & Latest Developments
Table 110. General Electric Company Summary
Table 111. General Electric Gammaretroviral Vector Product Offerings
Table 112. General Electric Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 113. General Electric Key News & Latest Developments
Table 114. Pfizer Inc Company Summary
Table 115. Pfizer Inc Gammaretroviral Vector Product Offerings
Table 116. Pfizer Inc Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 117. Pfizer Inc Key News & Latest Developments
Table 118. Genezen Company Summary
Table 119. Genezen Gammaretroviral Vector Product Offerings
Table 120. Genezen Gammaretroviral Vector Sales (K Units), Revenue (US$, Mn) and Average Price (US$/Unit) & (2020-2025)
Table 121. Genezen Key News & Latest Developments
Table 122. Gammaretroviral Vector Capacity of Key Manufacturers in Global Market, 2023-2025 (K Units)
Table 123. Global Gammaretroviral Vector Capacity Market Share of Key Manufacturers, 2023-2025
Table 124. Global Gammaretroviral Vector Production by Region, 2020-2025 (K Units)
Table 125. Global Gammaretroviral Vector Production by Region, 2026-2032 (K Units)
Table 126. Gammaretroviral Vector Market Opportunities & Trends in Global Market
Table 127. Gammaretroviral Vector Market Drivers in Global Market
Table 128. Gammaretroviral Vector Market Restraints in Global Market
Table 129. Gammaretroviral Vector Raw Materials
Table 130. Gammaretroviral Vector Raw Materials Suppliers in Global Market
Table 131. Typical Gammaretroviral Vector Downstream
Table 132. Gammaretroviral Vector Downstream Clients in Global Market
Table 133. Gammaretroviral Vector Distributors and Sales Agents in Global Market


List of Figures
Figure 1. Gammaretroviral Vector Product Picture
Figure 2. Gammaretroviral Vector Segment by Type in 2024
Figure 3. Gammaretroviral Vector Segment by Application in 2024
Figure 4. Global Gammaretroviral Vector Market Overview: 2024
Figure 5. Key Caveats
Figure 6. Global Gammaretroviral Vector Market Size: 2024 VS 2032 (US$, Mn)
Figure 7. Global Gammaretroviral Vector Revenue: 2020-2032 (US$, Mn)
Figure 8. Gammaretroviral Vector Sales in Global Market: 2020-2032 (K Units)
Figure 9. The Top 3 and 5 Players Market Share by Gammaretroviral Vector Revenue in 2024
Figure 10. Segment by Type � Global Gammaretroviral Vector Revenue, (US$, Mn), 2024 & 2032
Figure 11. Segment by Type - Global Gammaretroviral Vector Revenue Market Share, 2020-2032
Figure 12. Segment by Type - Global Gammaretroviral Vector Sales Market Share, 2020-2032
Figure 13. Segment by Type - Global Gammaretroviral Vector Price (US$/Unit), 2020-2032
Figure 14. Segment by Application � Global Gammaretroviral Vector Revenue, (US$, Mn), 2024 & 2032
Figure 15. Segment by Application - Global Gammaretroviral Vector Revenue Market Share, 2020-2032
Figure 16. Segment by Application - Global Gammaretroviral Vector Sales Market Share, 2020-2032
Figure 17. Segment by Application -Global Gammaretroviral Vector Price (US$/Unit), 2020-2032
Figure 18. By Region � Global Gammaretroviral Vector Revenue, (US$, Mn), 2025 & 2032
Figure 19. By Region - Global Gammaretroviral Vector Revenue Market Share, 2020 VS 2024 VS 2032
Figure 20. By Region - Global Gammaretroviral Vector Revenue Market Share, 2020-2032
Figure 21. By Region - Global Gammaretroviral Vector Sales Market Share, 2020-2032
Figure 22. By Country - North America Gammaretroviral Vector Revenue Market Share, 2020-2032
Figure 23. By Country - North America Gammaretroviral Vector Sales Market Share, 2020-2032
Figure 24. United States Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 25. Canada Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 26. Mexico Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 27. By Country - Europe Gammaretroviral Vector Revenue Market Share, 2020-2032
Figure 28. By Country - Europe Gammaretroviral Vector Sales Market Share, 2020-2032
Figure 29. Germany Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 30. France Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 31. U.K. Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 32. Italy Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 33. Russia Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 34. Nordic Countries Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 35. Benelux Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 36. By Region - Asia Gammaretroviral Vector Revenue Market Share, 2020-2032
Figure 37. By Region - Asia Gammaretroviral Vector Sales Market Share, 2020-2032
Figure 38. China Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 39. Japan Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 40. South Korea Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 41. Southeast Asia Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 42. India Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 43. By Country - South America Gammaretroviral Vector Revenue Market Share, 2020-2032
Figure 44. By Country - South America Gammaretroviral Vector Sales, Market Share, 2020-2032
Figure 45. Brazil Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 46. Argentina Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 47. By Country - Middle East & Africa Gammaretroviral Vector Revenue, Market Share, 2020-2032
Figure 48. By Country - Middle East & Africa Gammaretroviral Vector Sales, Market Share, 2020-2032
Figure 49. Turkey Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 50. Israel Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 51. Saudi Arabia Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 52. UAE Gammaretroviral Vector Revenue, (US$, Mn), 2020-2032
Figure 53. Global Gammaretroviral Vector Production Capacity (K Units), 2020-2032
Figure 54. The Percentage of Production Gammaretroviral Vector by Region, 2024 VS 2032
Figure 55. Gammaretroviral Vector Industry Value Chain
Figure 56. Marketing Channels
No data available

REPORT PURCHASE OPTIONS

USD Single User Price
USD Multi User Price
USD Enterprise Price

---- OR ----

Frequently Asked Questions

  • Up to 24 hrs - Working days
  • Up to 48 hrs max - Weekends & holidays

  • Email
  • Hard Copy

  • Single User License
  • Multi-User License
  • Site License
  • Corporate License

  • PayPal & CCavenue
  • Wire Transfer/Bank Transfer

Our Key Features

  • Data Accuracy and Reliability
  • Data Security
  • Customized Research
  • Trustworthy
  • Competitive Offerings