Struct CreateOrder 

pub struct CreateOrder {

    pub text: Option<String>,
    pub currency_pair: String,
    pub order_type: Option<String>,
    pub account: Option<String>,
    pub side: String,
    pub amount: String,
    pub price: Option<String>,
    pub time_in_force: Option<String>,
    pub iceberg: Option<String>,
    pub auto_borrow: Option<bool>,
    pub auto_repay: Option<bool>,
    pub stp_act: Option<String>,
    pub action_mode: Option<String>,
    pub x_gate_exp_time: Option<u128>,
    pub credentials: Option<Credentials>,
}

Request builder for creating trading orders.

Creates a new buy or sell order on Gate.io spot markets. Supports various order types including limit, market, immediate-or-cancel (IOC), and fill-or-kill (FOK) orders.

API Endpoint

POST /api/v4/spot/orders

Authentication

This endpoint requires API key authentication with signing.

Examples

use gateio_rs::{
    api::spot::create_order,
    http::Credentials,
    ureq::GateHttpClient,
};

let credentials = Credentials::new("api_key", "api_secret");
let client = GateHttpClient::default().credentials(credentials);

// Limit buy order
let request = create_order("BTC_USDT", "buy", "0.001")
    .price("50000")
    .order_type("limit")
    .time_in_force("gtc")
    .text("t-my-order-123");
let response = client.send(request)?;

// Market sell order
let request = create_order("BTC_USDT", "sell", "0.001")
    .order_type("market");
let response = client.send(request)?;

Parameter Details

Order Types (order_type)

• "limit": Limit order (default) - requires price
• "market": Market order - executes immediately at market price
• "ioc": Immediate-or-cancel - taker only
• "poc": Post-only - maker only (enjoys maker fee)
• "fok": Fill-or-kill - complete fill or cancel

Time in Force (time_in_force)

• "gtc": Good-till-cancelled (default)
• "ioc": Immediate-or-cancel
• "poc": Post-only
• "fok": Fill-or-kill

Amount Rules

• Limit orders: Amount refers to base currency (e.g., BTC in BTC_USDT)
• Market buy: Amount refers to quote currency (e.g., USDT in BTC_USDT)
• Market sell: Amount refers to base currency (e.g., BTC in BTC_USDT)

Account Types (account)

• "spot": Spot trading account
• "margin": Margin trading account
• "cross_margin": Cross margin account
• "unified": Unified account

Self-Trading Prevention (stp_act)

• "cn": Cancel newest orders
• "co": Cancel oldest orders
• "cb": Cancel both old and new orders

Text Field Rules

Custom order ID must:

• Be prefixed with "t-"
• Be no longer than 28 bytes (excluding prefix)
• Contain only: 0-9, A-Z, a-z, underscore, hyphen, or dot

Fields

text: Option<String>

Custom order ID

currency_pair: String

Trading pair

order_type: Option<String>

Order type

account: Option<String>

Account type

side: String

Order side

amount: String

Order amount

price: Option<String>

Order price

time_in_force: Option<String>

Time in force

iceberg: Option<String>

Iceberg amount

auto_borrow: Option<bool>

Auto borrow funds

auto_repay: Option<bool>

Auto repay borrowed

stp_act: Option<String>

Self-trade prevention

action_mode: Option<String>

Processing mode

x_gate_exp_time: Option<u128>

Request expiration time

credentials: Option<Credentials>

API credentials

Implementations

impl CreateOrder

pub fn new(currency_pair: &str, side: &str, amount: &str) -> Self

Create new order request

pub fn text(self, text: &str) -> Self

Set custom order ID

pub fn order_type(self, order_type: &str) -> Self

Set order type

Examples found in repository

examples/sync/create_order.rs (line 15)

fn main() -> Result<(), Box<gateio_rs::ureq::Error>> {
    dotenv::dotenv().ok();

    let api_key = std::env::var("GATE_API_KEY").expect("GATE_API_KEY not set");
    let api_secret = std::env::var("GATE_API_SECRET").expect("GATE_API_SECRET not set");
    let credentials = Credentials::new(api_key, api_secret);

    let client = GateHttpClient::default().credentials(credentials.clone());

    // Create a limit order
    let req = spot::create_order("DUREV_USDT", "buy", "800")
        .order_type("limit")
        .price("0.004")
        .time_in_force("gtc")
        .account("spot");

    // Create a market order
    // let req = spot::create_order("DUREV_USDT", "sell", "0")
    //     .order_type("market")
    //     .time_in_force("ioc");
    // .account("spot");

    let resp = client.send(req)?;
    let body = resp.into_body_str()?;
    let resp_obj: Value = serde_json::from_str(&body).unwrap();
    println!("{:?}", resp_obj);

    Ok(())
}

pub fn account(self, account: &str) -> Self

Set account type

Examples found in repository

examples/sync/create_order.rs (line 18)

fn main() -> Result<(), Box<gateio_rs::ureq::Error>> {
    dotenv::dotenv().ok();

    let api_key = std::env::var("GATE_API_KEY").expect("GATE_API_KEY not set");
    let api_secret = std::env::var("GATE_API_SECRET").expect("GATE_API_SECRET not set");
    let credentials = Credentials::new(api_key, api_secret);

    let client = GateHttpClient::default().credentials(credentials.clone());

    // Create a limit order
    let req = spot::create_order("DUREV_USDT", "buy", "800")
        .order_type("limit")
        .price("0.004")
        .time_in_force("gtc")
        .account("spot");

    // Create a market order
    // let req = spot::create_order("DUREV_USDT", "sell", "0")
    //     .order_type("market")
    //     .time_in_force("ioc");
    // .account("spot");

    let resp = client.send(req)?;
    let body = resp.into_body_str()?;
    let resp_obj: Value = serde_json::from_str(&body).unwrap();
    println!("{:?}", resp_obj);

    Ok(())
}

pub fn price(self, price: &str) -> Self

Set order price

Examples found in repository

examples/sync/create_order.rs (line 16)

fn main() -> Result<(), Box<gateio_rs::ureq::Error>> {
    dotenv::dotenv().ok();

    let api_key = std::env::var("GATE_API_KEY").expect("GATE_API_KEY not set");
    let api_secret = std::env::var("GATE_API_SECRET").expect("GATE_API_SECRET not set");
    let credentials = Credentials::new(api_key, api_secret);

    let client = GateHttpClient::default().credentials(credentials.clone());

    // Create a limit order
    let req = spot::create_order("DUREV_USDT", "buy", "800")
        .order_type("limit")
        .price("0.004")
        .time_in_force("gtc")
        .account("spot");

    // Create a market order
    // let req = spot::create_order("DUREV_USDT", "sell", "0")
    //     .order_type("market")
    //     .time_in_force("ioc");
    // .account("spot");

    let resp = client.send(req)?;
    let body = resp.into_body_str()?;
    let resp_obj: Value = serde_json::from_str(&body).unwrap();
    println!("{:?}", resp_obj);

    Ok(())
}

examples/sync_example.rs (line 70)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1) Create Credentials
    // TODO: Replace with your actual API credentials or use environment variables
    let api_key = "YOUR_GATE_API_KEY";
    let api_secret = "YOUR_GATE_API_SECRET";
    let credentials = Credentials::new(api_key.to_owned(), api_secret.to_owned());

    // 2) Configure Client
    let client = GateHttpClient::default().credentials(credentials);

    // 3) Send sync request examples

    // Example 1: Get ticker
    println!("Getting ticker for BTC_USDT...");
    let req = get_ticker().currency_pair("BTC_USDT").timezone("utc8");

    let resp = client.send(req)?;
    let body = resp.into_body_str()?;
    let ticker_data: Value = serde_json::from_str(&body)?;
    println!("Ticker: {}\n", serde_json::to_string_pretty(&ticker_data)?);

    // Example 2: Get account information
    println!("Getting account information...");
    let req = get_account();

    let resp = client.send(req)?;
    let body = resp.into_body_str()?;
    let account_data: Value = serde_json::from_str(&body)?;
    println!(
        "Account: {}\n",
        serde_json::to_string_pretty(&account_data)?
    );

    // Example 3: Get currency pairs
    println!("Getting currency pairs...");
    let req = get_currency_pairs();

    let resp = client.send(req)?;
    let body = resp.into_body_str()?;
    let pairs_data: Value = serde_json::from_str(&body)?;
    println!(
        "Found {} currency pairs\n",
        pairs_data.as_array().map(|a| a.len()).unwrap_or(0)
    );

    // Example 4: Get specific currency pair
    println!("Getting LTC_USDT currency pair info...");
    let req = get_currency_pair("LTC_USDT");

    let resp = client.send(req)?;
    let body = resp.into_body_str()?;
    let pair_data: Value = serde_json::from_str(&body)?;
    println!(
        "LTC_USDT info: {}\n",
        serde_json::to_string_pretty(&pair_data)?
    );

    // Example 5: Create order
    println!("Creating order...");
    let req = create_order("LTC_USDT", "buy", "0.04").price("84.2");

    let resp = client.send(req)?;
    let body = resp.into_body_str()?;
    let order_data: Value = serde_json::from_str(&body)?;
    println!(
        "Order created: {}\n",
        serde_json::to_string_pretty(&order_data)?
    );

    // Example 6: Batch user fee
    println!("Getting batch user fee...");
    let req = get_batch_user_fee("BTC_USDT,ETH_USDT");

    let resp = client.send(req)?;
    let body = resp.into_body_str()?;
    let fee_data: Value = serde_json::from_str(&body)?;
    println!("Fees: {}\n", serde_json::to_string_pretty(&fee_data)?);

    // Example 7: Account book
    println!("Getting account book...");
    let req = get_account_book().book_type("new_order");

    let resp = client.send(req)?;
    let body = resp.into_body_str()?;
    let book_data: Value = serde_json::from_str(&body)?;
    println!(
        "Account book: {}\n",
        serde_json::to_string_pretty(&book_data)?
    );

    // Example 8: Batch orders
    println!("Creating batch orders...");
    let order1 = Order::new("BTC_USDT", "buy", "0.001")
        .text("t-abc123")
        .order_type("limit")
        .account("unified")
        .price("65000")
        .time_in_force("gtc")
        .iceberg("0");

    let order2 = Order::new("ETH_USDT", "buy", "0.01")
        .text("t-def456")
        .order_type("limit")
        .account("unified")
        .price("3000")
        .time_in_force("gtc")
        .iceberg("0");

    let orders = vec![order1, order2];
    let req = create_batch_orders(orders);

    let resp = client.send(req)?;
    let body = resp.into_body_str()?;
    let batch_data: Value = serde_json::from_str(&body)?;
    println!(
        "Batch orders: {}\n",
        serde_json::to_string_pretty(&batch_data)?
    );

    println!("All sync examples completed successfully!");
    Ok(())
}

pub fn time_in_force(self, time_in_force: &str) -> Self

Set time in force

Examples found in repository

examples/sync/create_order.rs (line 17)

fn main() -> Result<(), Box<gateio_rs::ureq::Error>> {
    dotenv::dotenv().ok();

    let api_key = std::env::var("GATE_API_KEY").expect("GATE_API_KEY not set");
    let api_secret = std::env::var("GATE_API_SECRET").expect("GATE_API_SECRET not set");
    let credentials = Credentials::new(api_key, api_secret);

    let client = GateHttpClient::default().credentials(credentials.clone());

    // Create a limit order
    let req = spot::create_order("DUREV_USDT", "buy", "800")
        .order_type("limit")
        .price("0.004")
        .time_in_force("gtc")
        .account("spot");

    // Create a market order
    // let req = spot::create_order("DUREV_USDT", "sell", "0")
    //     .order_type("market")
    //     .time_in_force("ioc");
    // .account("spot");

    let resp = client.send(req)?;
    let body = resp.into_body_str()?;
    let resp_obj: Value = serde_json::from_str(&body).unwrap();
    println!("{:?}", resp_obj);

    Ok(())
}

pub fn iceberg(self, iceberg: &str) -> Self

Set iceberg amount

pub fn auto_borrow(self, auto_borrow: bool) -> Self

Enable auto borrow

pub fn auto_repay(self, auto_repay: bool) -> Self

Enable auto repay

pub fn stp_act(self, stp_act: &str) -> Self

Set self-trade prevention

pub fn action_mode(self, action_mode: &str) -> Self

Set processing mode

pub fn x_gate_exp_time(self, x_gate_exp_time: u128) -> Self

Set expiration time

pub fn credentials(self, creds: Credentials) -> Self

Set API credentials

Trait Implementations

impl From<CreateOrder> for Request

fn from(request: CreateOrder) -> Request

Converts to this type from the input type.