Orders Endpoint¶

Order creation, modification, and management.

post_order¶

Create a new order using any order request type.

OANDA Endpoint: POST /v3/accounts/{accountID}/orders

import asyncio
from decimal import Decimal

from dotenv import load_dotenv

from fivetwenty import AsyncClient
from fivetwenty.endpoints.orders import OrderResponse
from fivetwenty.models import InstrumentName, MarketOrderRequest

load_dotenv()


async def main() -> None:
    async with AsyncClient() as client:
        # Create a market order using the generic post_order method
        order_response: OrderResponse = await client.orders.post_order(
            account_id=client.account_id,
            order_request=MarketOrderRequest(
                instrument=InstrumentName.EUR_USD,
                units=Decimal(1000),
            ),
            client_request_id="my-order-123",
        )
        print(f"Last Transaction ID: {order_response['lastTransactionID']}")


if __name__ == "__main__":
    asyncio.run(main())

🔗 OANDA Documentation: Create Order

🔗 Source: orders.post_order

Parameters:

Parameter	Type	Required	Description
`account_id`	AccountID	✅	Target account identifier
`order_request`	MarketOrderRequest \| LimitOrderRequest \| StopOrderRequest \| TakeProfitOrderRequest \| StopLossOrderRequest \| MarketIfTouchedOrderRequest \| TrailingStopLossOrderRequest \| GuaranteedStopLossOrderRequest	✅	Order specification
`*`			Keyword-only parameters below
`timeout`	float \| None	➖	Request timeout override
`client_request_id`	str \| None	➖	Client-provided request ID for debugging and correlation

Returns: OrderResponse TypedDict containing:

lastTransactionID: Transaction ID string
orderCreateTransaction: Transaction details for the created order
orderFillTransaction: Transaction details if order was filled (optional)
relatedTransactionIDs: List of related transaction IDs

Raises:

FiveTwentyError - API errors:

401/403: Authentication failed (check e.is_authentication_error)
404: Account not found (check e.is_not_found)
429: Rate limit exceeded (check e.is_rate_limited, use e.retry_after)
400: Invalid order parameters (check e.is_validation_error)
ValueError - If order_request is invalid or missing required fields

post_market_order¶

Create a market order (convenience method for immediate execution at current market price).

OANDA Endpoint: POST /v3/accounts/{accountID}/orders

import asyncio
from decimal import Decimal

from dotenv import load_dotenv

from fivetwenty import AsyncClient
from fivetwenty.endpoints.orders import OrderResponse
from fivetwenty.models import InstrumentName

load_dotenv()


async def main() -> None:
    async with AsyncClient() as client:
        # Create a market order with take profit and stop loss
        order: OrderResponse = await client.orders.post_market_order(
            account_id=client.account_id,
            instrument=InstrumentName.EUR_USD,
            units=1000,
            take_profit=Decimal("1.1500"),
            stop_loss=Decimal("1.1200"),
        )
        print(f"Last Transaction ID: {order['lastTransactionID']}")


if __name__ == "__main__":
    asyncio.run(main())

🔗 OANDA Documentation: Create Order

🔗 Source: orders.post_market_order

Parameters:

Parameter	Type	Required	Description
`account_id`	AccountID	✅	Account to create order for
`instrument`	InstrumentName	✅	Instrument to trade
`units`	int \| Decimal \| str	✅	Number of units (positive = buy, negative = sell)
`*`			Keyword-only parameters below
`take_profit`	Decimal \| None	➖	Take profit price (creates takeProfitOnFill order)
`stop_loss`	Decimal \| None	➖	Stop loss price (creates stopLossOnFill order)
`timeout`	float \| None	➖	Request timeout override
`client_request_id`	str \| None	➖	Client-provided request ID for debugging and correlation

Returns: OrderResponse TypedDict containing:

lastTransactionID: Transaction ID string
orderCreateTransaction: Transaction details for the created order
orderFillTransaction: Transaction details if order was filled (optional)
relatedTransactionIDs: List of related transaction IDs

Raises:

FiveTwentyError - API errors:

401/403: Authentication failed (check e.is_authentication_error)
404: Account not found (check e.is_not_found)
429: Rate limit exceeded (check e.is_rate_limited, use e.retry_after)
400: Invalid parameters or insufficient margin (check e.is_validation_error)

post_limit_order¶

Create a limit order (convenience method for order execution at specified price or better).

OANDA Endpoint: POST /v3/accounts/{accountID}/orders

import asyncio
from decimal import Decimal

from dotenv import load_dotenv

from fivetwenty import AsyncClient
from fivetwenty.endpoints.orders import OrderResponse
from fivetwenty.models import InstrumentName

load_dotenv()


async def main() -> None:
    async with AsyncClient() as client:
        # Create a limit order to buy EUR/USD at 1.1350
        order: OrderResponse = await client.orders.post_limit_order(
            account_id=client.account_id,
            instrument=InstrumentName.EUR_USD,
            units=1000,
            price=Decimal("1.1350"),
        )
        print(f"Last Transaction ID: {order['lastTransactionID']}")


if __name__ == "__main__":
    asyncio.run(main())

🔗 OANDA Documentation: Create Order

🔗 Source: orders.post_limit_order

Parameters:

Parameter	Type	Required	Description
`account_id`	AccountID	✅	Account to create order for
`instrument`	InstrumentName	✅	Instrument to trade
`units`	int \| Decimal \| str	✅	Number of units (positive = buy, negative = sell)
`price`	Decimal	✅	Limit price
`*`			Keyword-only parameters below
`time_in_force`	str	➖	Order time in force (GTC, GTD, GFD, FOK, IOC) - default: "GTC"
`take_profit`	Decimal \| None	➖	Take profit price (creates takeProfitOnFill order)
`stop_loss`	Decimal \| None	➖	Stop loss price (creates stopLossOnFill order)
`timeout`	float \| None	➖	Request timeout override
`client_request_id`	str \| None	➖	Client-provided request ID for debugging and correlation

Returns: OrderResponse TypedDict containing:

lastTransactionID: Transaction ID string
orderCreateTransaction: Transaction details for the created order
relatedTransactionIDs: List of related transaction IDs

Raises:

FiveTwentyError - API errors:

401/403: Authentication failed (check e.is_authentication_error)
404: Account not found (check e.is_not_found)
429: Rate limit exceeded (check e.is_rate_limited, use e.retry_after)
400: Invalid parameters (check e.is_validation_error)

post_stop_order¶

Create a stop order (convenience method for order execution when market reaches trigger price).

OANDA Endpoint: POST /v3/accounts/{accountID}/orders

import asyncio
from decimal import Decimal

from dotenv import load_dotenv

from fivetwenty import AsyncClient
from fivetwenty.endpoints.orders import OrderResponse
from fivetwenty.models import InstrumentName

load_dotenv()


async def main() -> None:
    async with AsyncClient() as client:
        # Create a stop order triggered when EUR/USD reaches 1.1200
        order: OrderResponse = await client.orders.post_stop_order(
            account_id=client.account_id,
            instrument=InstrumentName.EUR_USD,
            units=1000,
            price=Decimal("1.1200"),
        )
        print(f"Last Transaction ID: {order['lastTransactionID']}")


if __name__ == "__main__":
    asyncio.run(main())

🔗 OANDA Documentation: Create Order

🔗 Source: orders.post_stop_order

Parameters:

Parameter	Type	Required	Description
`account_id`	AccountID	✅	Account to create order for
`instrument`	InstrumentName	✅	Instrument to trade
`units`	int \| Decimal \| str	✅	Number of units (positive = buy, negative = sell)
`price`	Decimal	✅	Stop trigger price
`*`			Keyword-only parameters below
`price_bound`	Decimal \| None	➖	Maximum slippage price after trigger
`time_in_force`	str	➖	Order time in force (GTC, GTD, GFD, FOK, IOC) - default: "GTC"
`take_profit`	Decimal \| None	➖	Take profit price (creates takeProfitOnFill order)
`stop_loss`	Decimal \| None	➖	Stop loss price (creates stopLossOnFill order)
`timeout`	float \| None	➖	Request timeout override
`client_request_id`	str \| None	➖	Client-provided request ID for debugging and correlation

Returns: OrderResponse TypedDict containing:

lastTransactionID: Transaction ID string
orderCreateTransaction: Transaction details for the created order
relatedTransactionIDs: List of related transaction IDs

Raises:

FiveTwentyError - API errors:

401/403: Authentication failed (check e.is_authentication_error)
404: Account not found (check e.is_not_found)
429: Rate limit exceeded (check e.is_rate_limited, use e.retry_after)
400: Invalid parameters (check e.is_validation_error)

post_market_if_touched_order¶

Create a market-if-touched order (convenience method for market order execution when price reaches trigger level).

OANDA Endpoint: POST /v3/accounts/{accountID}/orders

import asyncio
from decimal import Decimal

from dotenv import load_dotenv

from fivetwenty import AsyncClient
from fivetwenty.endpoints.orders import OrderResponse
from fivetwenty.models import InstrumentName

load_dotenv()


async def main() -> None:
    async with AsyncClient() as client:
        # Create market-if-touched order triggered at 1.1400
        order: OrderResponse = await client.orders.post_market_if_touched_order(
            account_id=client.account_id,
            instrument=InstrumentName.EUR_USD,
            units=1000,
            price=Decimal("1.1400"),
        )
        print(f"Last Transaction ID: {order['lastTransactionID']}")


if __name__ == "__main__":
    asyncio.run(main())

🔗 OANDA Documentation: Create Order

🔗 Source: orders.post_market_if_touched_order

Parameters:

Parameter	Type	Required	Description
`account_id`	AccountID	✅	Account to create order for
`instrument`	InstrumentName	✅	Instrument to trade
`units`	int \| Decimal \| str	✅	Number of units (positive = buy, negative = sell)
`price`	Decimal	✅	Trigger price
`*`			Keyword-only parameters below
`price_bound`	Decimal \| None	➖	Maximum slippage price after trigger
`time_in_force`	str	➖	Order time in force (GTC, GTD, GFD, FOK, IOC) - default: "GTC"
`take_profit`	Decimal \| None	➖	Take profit price (creates takeProfitOnFill order)
`stop_loss`	Decimal \| None	➖	Stop loss price (creates stopLossOnFill order)
`timeout`	float \| None	➖	Request timeout override
`client_request_id`	str \| None	➖	Client-provided request ID for debugging and correlation

Returns: OrderResponse TypedDict containing:

lastTransactionID: Transaction ID string
orderCreateTransaction: Transaction details for the created order
relatedTransactionIDs: List of related transaction IDs

Raises:

FiveTwentyError - API errors:

401/403: Authentication failed (check e.is_authentication_error)
404: Account not found (check e.is_not_found)
429: Rate limit exceeded (check e.is_rate_limited, use e.retry_after)
400: Invalid parameters (check e.is_validation_error)

get_orders¶

Get a list of orders for an account with optional filtering.

OANDA Endpoint: GET /v3/accounts/{accountID}/orders

import asyncio

from dotenv import load_dotenv

from fivetwenty import AsyncClient

load_dotenv()


async def main() -> None:
    async with AsyncClient() as client:
        # Get pending orders for the account
        orders = await client.orders.get_orders(
            account_id=client.account_id,
            state="PENDING",
            count=50,
        )
        print(f"Found {len(orders)} orders")


if __name__ == "__main__":
    asyncio.run(main())

🔗 OANDA Documentation: Get Orders

🔗 Source: orders.get_orders

Parameters:

Parameter	Type	Required	Description
`account_id`	AccountID	✅	Target account identifier
`*`			Keyword-only parameters below
`ids`	list[str] \| None	➖	List of specific order IDs to retrieve
`state`	str	➖	Filter by order state - default: "PENDING"
`instrument`	str \| None	➖	Filter by instrument
`count`	int	➖	Maximum number of orders to return - default: 50
`before_id`	str \| None	➖	Maximum order ID to return

Returns: list[Order] - List of Order models

Raises:

FiveTwentyError - API errors:

401/403: Authentication failed (check e.is_authentication_error)
404: Account not found (check e.is_not_found)
429: Rate limit exceeded (check e.is_rate_limited, use e.retry_after)
400: Invalid filter parameters (check e.is_validation_error)

get_order¶

Get details for a specific order by order ID or specifier.

OANDA Endpoint: GET /v3/accounts/{accountID}/orders/{orderSpecifier}

import asyncio

from dotenv import load_dotenv

from fivetwenty import AsyncClient
from fivetwenty.endpoints.orders import GetOrderResponse

load_dotenv()


async def main() -> None:
    async with AsyncClient() as client:
        # Get details for a specific order
        # Replace with your actual order ID
        result: GetOrderResponse = await client.orders.get_order(
            account_id=client.account_id,
            order_specifier="12345",
        )
        order = result["order"]
        print(f"Order type: {order.type}")
        print(f"Last Transaction ID: {result['lastTransactionID']}")


if __name__ == "__main__":
    asyncio.run(main())

🔗 OANDA Documentation: Get Order

🔗 Source: orders.get_order

Parameters:

Parameter	Type	Required	Description
`account_id`	AccountID	✅	Target account identifier
`order_specifier`	str	✅	Order identifier or specifier

Returns: GetOrderResponse TypedDict containing:

order: Order model with full order details
lastTransactionID: Transaction ID string

Raises:

FiveTwentyError - API errors:

401/403: Authentication failed (check e.is_authentication_error)
404: Order or account not found (check e.is_not_found)
429: Rate limit exceeded (check e.is_rate_limited, use e.retry_after)

cancel_order¶

Cancel a pending order by order ID or specifier.

OANDA Endpoint: PUT /v3/accounts/{accountID}/orders/{orderSpecifier}/cancel

import asyncio

from dotenv import load_dotenv

from fivetwenty import AsyncClient
from fivetwenty.endpoints.orders import CancelOrderResponse

load_dotenv()


async def main() -> None:
    async with AsyncClient() as client:
        # Cancel a pending order
        # Replace with your actual order ID
        result: CancelOrderResponse = await client.orders.cancel_order(
            account_id=client.account_id,
            order_specifier="12345",
        )
        print(f"Last Transaction ID: {result['lastTransactionID']}")


if __name__ == "__main__":
    asyncio.run(main())

🔗 OANDA Documentation: Cancel Order

🔗 Source: orders.cancel_order

Parameters:

Parameter	Type	Required	Description
`account_id`	AccountID	✅	Target account identifier
`order_specifier`	str	✅	Order identifier to cancel
`*`			Keyword-only parameters below
`timeout`	float \| None	➖	Request timeout override
`client_request_id`	str \| None	➖	Client-provided request ID for debugging and correlation

Returns: CancelOrderResponse TypedDict containing:

orderCancelTransaction: Transaction details for the cancellation
relatedTransactionIDs: List of related transaction IDs
lastTransactionID: Transaction ID string

Raises:

FiveTwentyError - API errors:

401/403: Authentication failed (check e.is_authentication_error)
404: Order or account not found (check e.is_not_found)
429: Rate limit exceeded (check e.is_rate_limited, use e.retry_after)
400: Order not cancellable (already filled or cancelled) (check e.is_validation_error)

get_pending_orders¶

Get all pending orders for an account.

OANDA Endpoint: GET /v3/accounts/{accountID}/pendingOrders

import asyncio

from dotenv import load_dotenv

from fivetwenty import AsyncClient
from fivetwenty.endpoints.orders import PendingOrdersResponse

load_dotenv()


async def main() -> None:
    async with AsyncClient() as client:
        # Get all pending orders
        result: PendingOrdersResponse = await client.orders.get_pending_orders(
            account_id=client.account_id
        )
        pending_orders = result["orders"]
        print(f"Found {len(pending_orders)} pending orders")
        print(f"Last Transaction ID: {result['lastTransactionID']}")


if __name__ == "__main__":
    asyncio.run(main())

🔗 OANDA Documentation: Get Pending Orders

🔗 Source: orders.get_pending_orders

Parameters:

Parameter	Type	Required	Description
`account_id`	AccountID	✅	Target account identifier

Returns: PendingOrdersResponse TypedDict containing:

orders: List of pending Order models
lastTransactionID: Transaction ID string

Raises:

FiveTwentyError - API errors:

401/403: Authentication failed (check e.is_authentication_error)
404: Account not found (check e.is_not_found)
429: Rate limit exceeded (check e.is_rate_limited, use e.retry_after)

put_order¶

Replace an existing order by cancelling it and creating a new order with updated parameters.

OANDA Endpoint: PUT /v3/accounts/{accountID}/orders/{orderSpecifier}

import asyncio
from decimal import Decimal

from dotenv import load_dotenv

from fivetwenty import AsyncClient
from fivetwenty.endpoints.orders import ReplaceOrderResponse
from fivetwenty.models import InstrumentName, LimitOrderRequest

load_dotenv()


async def main() -> None:
    async with AsyncClient() as client:
        # Replace an existing limit order with new price
        # Replace with your actual order ID
        result: ReplaceOrderResponse = await client.orders.put_order(
            account_id=client.account_id,
            order_specifier="12345",
            order_request=LimitOrderRequest(
                instrument=InstrumentName.EUR_USD,
                units=Decimal("1000"),
                price=Decimal("1.1400"),
            ),
        )
        print(f"Last Transaction ID: {result['lastTransactionID']}")


if __name__ == "__main__":
    asyncio.run(main())

🔗 OANDA Documentation: Replace Order

🔗 Source: orders.put_order

Parameters:

Parameter	Type	Required	Description
`account_id`	AccountID	✅	Target account identifier
`order_specifier`	str	✅	Order identifier to replace
`order_request`	MarketOrderRequest \| LimitOrderRequest \| StopOrderRequest \| TakeProfitOrderRequest \| StopLossOrderRequest \| MarketIfTouchedOrderRequest \| TrailingStopLossOrderRequest \| GuaranteedStopLossOrderRequest	✅	New order specification
`*`			Keyword-only parameters below
`client_request_id`	str \| None	➖	Client-provided request ID for debugging and correlation

Returns: ReplaceOrderResponse TypedDict containing:

orderCancelTransaction: Transaction details for cancelled order (optional)
orderCreateTransaction: Transaction details for new order
orderFillTransaction: Transaction details if new order filled (optional)
relatedTransactionIDs: List of related transaction IDs
lastTransactionID: Transaction ID string

Raises:

FiveTwentyError - API errors:

401/403: Authentication failed (check e.is_authentication_error)
404: Order or account not found (check e.is_not_found)
429: Rate limit exceeded (check e.is_rate_limited, use e.retry_after)
400: Invalid order specification or replacement failed (check e.is_validation_error)

put_order_client_extensions¶

Modify client extensions for an existing order without replacing the order.

OANDA Endpoint: PUT /v3/accounts/{accountID}/orders/{orderSpecifier}/clientExtensions

import asyncio

from dotenv import load_dotenv

from fivetwenty import AsyncClient
from fivetwenty.endpoints.orders import OrderClientExtensionsResponse
from fivetwenty.models import ClientExtensions

load_dotenv()


async def main() -> None:
    async with AsyncClient() as client:
        # Update client extensions for an order
        # Replace with your actual order ID
        result: OrderClientExtensionsResponse = (
            await client.orders.put_order_client_extensions(
                account_id=client.account_id,
                order_specifier="12345",
                client_extensions=ClientExtensions(comment="Updated order"),
            )
        )
        print(f"Last Transaction ID: {result['lastTransactionID']}")


if __name__ == "__main__":
    asyncio.run(main())

🔗 OANDA Documentation: Update Order Client Extensions

🔗 Source: orders.put_order_client_extensions

Parameters:

Parameter	Type	Required	Description
`account_id`	AccountID	✅	Target account identifier
`order_specifier`	str	✅	Order identifier to modify
`*`			Keyword-only parameters below
`client_extensions`	ClientExtensions \| None	➖	New order client extensions
`trade_client_extensions`	ClientExtensions \| None	➖	New trade client extensions

Returns: OrderClientExtensionsResponse TypedDict containing:

orderClientExtensionsModifyTransaction: Transaction details for the modification
relatedTransactionIDs: List of related transaction IDs
lastTransactionID: Transaction ID string

Raises:

FiveTwentyError - API errors:

401/403: Authentication failed (check e.is_authentication_error)
404: Order or account not found (check e.is_not_found)
429: Rate limit exceeded (check e.is_rate_limited, use e.retry_after)
400: Invalid client extensions or modification failed (check e.is_validation_error)

Orders Endpoint¶

post_order¶

post_market_order¶

post_limit_order¶

post_stop_order¶

post_market_if_touched_order¶

get_orders¶

get_order¶

cancel_order¶

get_pending_orders¶

put_order¶

put_order_client_extensions¶

Documentation

Community

Contributing

Legal & Support

OANDA Info