> For clean Markdown of any page, append .md to the page URL. > For a complete documentation index, see https://docs.ninjatrader.com/llms.txt. > For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.ninjatrader.com/_mcp/server. # Get Product Fee Params POST https://demo.tradovateapi.com/v1/contract/getproductfeeparams Content-Type: application/json ### Return the fee parameters for one or more products. **Available to:** All authenticated users **Environments:** Demo, Live **[Rate Limit](/api/authentication#request-rate-limits-and-time-penalties):** 300 requests per hour, 1-second back-off, counts all requests Return the per-contract fee and margin parameters for a set of products. Send a `productIds` array of numeric product IDs in the request body; this field is required. The response is a `params` array containing one `ProductFeeParams` object per resolved product, so it can be requested in a single batch rather than one product at a time. Each `ProductFeeParams` object reports the cost components applied to trading a product, keyed by `productId`. The fee fields are: `clearingFee`, `exchangeFee`, `nfaFee`, `brokerageFee`, `ipFee` (the IP/TT fee), `commission`, and `orderRoutingFee`. Each fee has a paired `*CurrencyId` field (for example, `exchangeCurrencyId`) identifying the currency the amount is denominated in, since fees can settle in different currencies. The object also carries notional-value rates — `commissionNotionalValueBPS` and `exchangeFeeNotionalValueBPS`, expressed in basis points — and the margin requirements `dayMargin`, `nightMargin`, and the structured `fullMargin` (`ProductMargin`). Resolve a `productId` from a contract with the ContractLibrary reads, such as [`contractItem`](/api/rest-api-endpoints/contract-library/contract-item) or [`contractFind`](/api/rest-api-endpoints/contract-library/contract-find). Products without configured fee parameters are omitted from `params` rather than returned with zeroed fields, so the response length can be shorter than the `productIds` request. **Common Failure Scenarios** - The `productIds` array is omitted or empty. - A supplied product ID does not exist; that product is omitted from the response. - The bearer access token is missing or expired. **Error Messages** This endpoint does not return a business `errorText` field. A failed request is signaled by the HTTP status; a successful request returns the `params` array. Reference: https://docs.ninjatrader.com/api/rest-api-endpoints/contract-library/get-product-fee-params ## OpenAPI Specification ```yaml openapi: 3.1.0 info: title: public version: 1.0.0 paths: /contract/getproductfeeparams: post: operationId: getProductFeeParams summary: Get Product Fee Params description: >- ### Return the fee parameters for one or more products. **Available to:** All authenticated users **Environments:** Demo, Live **[Rate Limit](/api/authentication#request-rate-limits-and-time-penalties):** 300 requests per hour, 1-second back-off, counts all requests Return the per-contract fee and margin parameters for a set of products. Send a `productIds` array of numeric product IDs in the request body; this field is required. The response is a `params` array containing one `ProductFeeParams` object per resolved product, so it can be requested in a single batch rather than one product at a time. Each `ProductFeeParams` object reports the cost components applied to trading a product, keyed by `productId`. The fee fields are: `clearingFee`, `exchangeFee`, `nfaFee`, `brokerageFee`, `ipFee` (the IP/TT fee), `commission`, and `orderRoutingFee`. Each fee has a paired `*CurrencyId` field (for example, `exchangeCurrencyId`) identifying the currency the amount is denominated in, since fees can settle in different currencies. The object also carries notional-value rates — `commissionNotionalValueBPS` and `exchangeFeeNotionalValueBPS`, expressed in basis points — and the margin requirements `dayMargin`, `nightMargin`, and the structured `fullMargin` (`ProductMargin`). Resolve a `productId` from a contract with the ContractLibrary reads, such as [`contractItem`](/api/rest-api-endpoints/contract-library/contract-item) or [`contractFind`](/api/rest-api-endpoints/contract-library/contract-find). Products without configured fee parameters are omitted from `params` rather than returned with zeroed fields, so the response length can be shorter than the `productIds` request. **Common Failure Scenarios** - The `productIds` array is omitted or empty. - A supplied product ID does not exist; that product is omitted from the response. - The bearer access token is missing or expired. **Error Messages** This endpoint does not return a business `errorText` field. A failed request is signaled by the HTTP status; a successful request returns the `params` array. tags: - contractLibrary parameters: - name: Authorization in: header description: Bearer authentication required: true schema: type: string responses: '200': description: ProductFeeParamsResponse content: application/json: schema: $ref: '#/components/schemas/ProductFeeParamsResponse' requestBody: content: application/json: schema: $ref: '#/components/schemas/GetProductFeeParams' servers: - url: https://demo.tradovateapi.com/v1 description: Demo - url: https://live.tradovateapi.com/v1 description: Live components: schemas: GetProductFeeParams: type: object properties: productIds: type: array items: type: integer format: int64 required: - productIds title: GetProductFeeParams ProductMargin: type: object properties: id: type: integer format: int64 initialMargin: type: number format: double maintenanceMargin: type: number format: double timestamp: type: string format: date-time required: - initialMargin - maintenanceMargin - timestamp title: ProductMargin ProductFeeParams: type: object properties: clearingFee: type: number format: double clearingCurrencyId: type: integer format: int64 exchangeFee: type: number format: double exchangeCurrencyId: type: integer format: int64 nfaFee: type: number format: double nfaCurrencyId: type: integer format: int64 brokerageFee: type: number format: double brokerageCurrencyId: type: integer format: int64 ipFee: type: number format: double description: IP/TT Fee ipCurrencyId: type: integer format: int64 commission: type: number format: double commissionCurrencyId: type: integer format: int64 orderRoutingFee: type: number format: double orderRoutingCurrencyId: type: integer format: int64 productId: type: integer format: int64 dayMargin: type: number format: double nightMargin: type: number format: double fullMargin: $ref: '#/components/schemas/ProductMargin' commissionNotionalValueBPS: type: number format: double exchangeFeeNotionalValueBPS: type: number format: double required: - productId title: ProductFeeParams ProductFeeParamsResponse: type: object properties: params: type: array items: $ref: '#/components/schemas/ProductFeeParams' required: - params title: ProductFeeParamsResponse securitySchemes: bearer_access_token: type: http scheme: bearer ``` ## Examples **Request** ```json { "productIds": [ 1 ] } ``` **Response** ```json { "params": [ { "productId": 1, "clearingFee": 1.1, "clearingCurrencyId": 1, "exchangeFee": 1.1, "exchangeCurrencyId": 1, "nfaFee": 1.1, "nfaCurrencyId": 1, "brokerageFee": 1.1, "brokerageCurrencyId": 1, "ipFee": 1.1, "ipCurrencyId": 1, "commission": 1.1, "commissionCurrencyId": 1, "orderRoutingFee": 1.1, "orderRoutingCurrencyId": 1, "dayMargin": 1.1, "nightMargin": 1.1, "fullMargin": { "initialMargin": 1.1, "maintenanceMargin": 1.1, "timestamp": "2024-01-15T09:30:00Z", "id": 1 }, "commissionNotionalValueBPS": 1.1, "exchangeFeeNotionalValueBPS": 1.1 } ] } ``` **SDK Code** ```python import requests url = "https://demo.tradovateapi.com/v1/contract/getproductfeeparams" payload = { "productIds": [1] } headers = { "Authorization": "Bearer ", "Content-Type": "application/json" } response = requests.post(url, json=payload, headers=headers) print(response.json()) ``` ```javascript const url = 'https://demo.tradovateapi.com/v1/contract/getproductfeeparams'; const options = { method: 'POST', headers: {Authorization: 'Bearer ', 'Content-Type': 'application/json'}, body: '{"productIds":[1]}' }; try { const response = await fetch(url, options); const data = await response.json(); console.log(data); } catch (error) { console.error(error); } ``` ```go package main import ( "fmt" "strings" "net/http" "io" ) func main() { url := "https://demo.tradovateapi.com/v1/contract/getproductfeeparams" payload := strings.NewReader("{\n \"productIds\": [\n 1\n ]\n}") req, _ := http.NewRequest("POST", url, payload) req.Header.Add("Authorization", "Bearer ") req.Header.Add("Content-Type", "application/json") res, _ := http.DefaultClient.Do(req) defer res.Body.Close() body, _ := io.ReadAll(res.Body) fmt.Println(res) fmt.Println(string(body)) } ``` ```ruby require 'uri' require 'net/http' url = URI("https://demo.tradovateapi.com/v1/contract/getproductfeeparams") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true request = Net::HTTP::Post.new(url) request["Authorization"] = 'Bearer ' request["Content-Type"] = 'application/json' request.body = "{\n \"productIds\": [\n 1\n ]\n}" response = http.request(request) puts response.read_body ``` ```java import com.mashape.unirest.http.HttpResponse; import com.mashape.unirest.http.Unirest; HttpResponse response = Unirest.post("https://demo.tradovateapi.com/v1/contract/getproductfeeparams") .header("Authorization", "Bearer ") .header("Content-Type", "application/json") .body("{\n \"productIds\": [\n 1\n ]\n}") .asString(); ``` ```php request('POST', 'https://demo.tradovateapi.com/v1/contract/getproductfeeparams', [ 'body' => '{ "productIds": [ 1 ] }', 'headers' => [ 'Authorization' => 'Bearer ', 'Content-Type' => 'application/json', ], ]); echo $response->getBody(); ``` ```csharp using RestSharp; var client = new RestClient("https://demo.tradovateapi.com/v1/contract/getproductfeeparams"); var request = new RestRequest(Method.POST); request.AddHeader("Authorization", "Bearer "); request.AddHeader("Content-Type", "application/json"); request.AddParameter("application/json", "{\n \"productIds\": [\n 1\n ]\n}", ParameterType.RequestBody); IRestResponse response = client.Execute(request); ``` ```swift import Foundation let headers = [ "Authorization": "Bearer ", "Content-Type": "application/json" ] let parameters = ["productIds": [1]] as [String : Any] let postData = JSONSerialization.data(withJSONObject: parameters, options: []) let request = NSMutableURLRequest(url: NSURL(string: "https://demo.tradovateapi.com/v1/contract/getproductfeeparams")! as URL, cachePolicy: .useProtocolCachePolicy, timeoutInterval: 10.0) request.httpMethod = "POST" request.allHTTPHeaderFields = headers request.httpBody = postData as Data let session = URLSession.shared let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in if (error != nil) { print(error as Any) } else { let httpResponse = response as? HTTPURLResponse print(httpResponse) } }) dataTask.resume() ```