Market Temperature

Get Current Market Temperature

SDK Links

Python	longport.openapi.QuoteContext.market_temperature
Rust	longport::quote::QuoteContext#market_temperature
Go	QuoteContext.MarketTemperature
Node.js	QuoteContext#marketTemperature

Request

HTTP Method	GET
HTTP URL	/v1/quote/market_temperature

Parameters

Name	Type	Required	Description
market	string	YES	Market, currently supports US, HK, SG, CN

Request Example

from longport.openapi import QuoteContext, Config, Market, OAuthBuilder

oauth = OAuthBuilder("your-client-id").build(lambda url: print("Visit:", url))
config = Config.from_oauth(oauth)
ctx = QuoteContext(config)
resp = ctx.market_temperature(Market.US)
print(resp)

import asyncio
from longport.openapi import AsyncQuoteContext, Config, Market, OAuthBuilder

async def main() -> None:
    oauth = await OAuthBuilder("your-client-id").build_async(lambda url: print("Visit:", url))
    config = Config.from_oauth(oauth)
    ctx = AsyncQuoteContext.create(config)
    resp = await ctx.market_temperature(Market.US)
    print(resp)

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

const { Config, QuoteContext, OAuth, Market } = require('longport')

async function main() {
  const oauth = await OAuth.build('your-client-id', (_, url) => {
    console.log('Open this URL to authorize: ' + url)
  })
  const config = Config.fromOAuth(oauth)
  const ctx = QuoteContext.new(config)
  const resp = await ctx.marketTemperature(Market.US)
  console.log(resp)
}
main().catch(console.error)

import com.longport.*;
import com.longport.quote.*;

class Main {
    public static void main(String[] args) throws Exception {
        try (OAuth oauth = new OAuthBuilder("your-client-id")
                .build(url -> System.out.println("Open to authorize: " + url))
                .get();
             Config config = Config.fromOAuth(oauth);
             QuoteContext ctx = QuoteContext.create(config)) {
            MarketTemperature resp = ctx.getMarketTemperature(Market.US).get();
            System.out.println(resp);
        }
    }
}

use std::sync::Arc;
use longport::{oauth::OAuthBuilder, quote::QuoteContext, Config, Market};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let oauth = OAuthBuilder::new("your-client-id")
        .build(|url| println!("Open this URL to authorize: {url}"))
        .await?;
    let config = Arc::new(Config::from_oauth(oauth));
    let (ctx, _) = QuoteContext::new(config);
    let resp = ctx.market_temperature(Market::US).await?;
    println!("{:?}", resp);
    Ok(())
}

#include <iostream>
#include <longport.hpp>

#ifdef WIN32
#include <windows.h>
#endif

using namespace longport;
using namespace longport::quote;

static void
run(const OAuth& oauth)
{
    Config config = Config::from_oauth(oauth);
    QuoteContext ctx = QuoteContext::create(config);

    ctx.market_temperature(Market::US, [](auto res) {
        if (!res) {
            std::cout << "failed: " << *res.status().message() << std::endl;
            return;
        }
        std::cout << "temperature: " << res->temperature << std::endl;
    });
}

int main(int argc, char const* argv[]) {
#ifdef WIN32
    SetConsoleOutputCP(CP_UTF8);
#endif

    const std::string client_id = "your-client-id";
    OAuthBuilder(client_id).build(
    [](const std::string& url) {
        std::cout << "Open this URL to authorize: " << url << std::endl;
    },
    [](auto res) {
        if (!res) {
            std::cout << "authorization failed: " << *res.status().message() << std::endl;
            return;
        }
        run(*res);
    });

    std::cin.get();
    return 0;
}

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/longportapp/openapi-go/config"
	"github.com/longportapp/openapi-go/oauth"
	"github.com/longportapp/openapi-go/quote"
)

func main() {
	o := oauth.New("your-client-id").
		OnOpenURL(func(url string) { fmt.Println("Open this URL to authorize:", url) })
	if err := o.Build(context.Background()); err != nil {
		log.Fatal(err)
	}
	conf, err := config.New(config.WithOAuthClient(o))
	if err != nil {
		log.Fatal(err)
	}
	qctx, err := quote.NewFromCfg(conf)
	if err != nil {
		log.Fatal(err)
	}
	defer qctx.Close()
	// Market temperature API: use HTTP client to call GET /v1/quote/market-temperature
	_ = qctx
	fmt.Println("See openapi-go for HTTP quote APIs")
}

Response

Response Headers

• Content-Type: application/json

Response Example

{
  "code": 0,
  "data": {
    "temperature": 50,
    "description": "Temperature is moderate, maintaining stability",
    "valuation": 23,
    "sentiment": 78,
    "updated_at": 1744616612
  }
}

Response Status

Status	Description	Schema
200	Success	MarketTemperatureResponse
400	Parameter Error	None

Schemas

MarketTemperatureResponse

Name	Type	Required	Description
temperature	integer	true	Temperature value
description	string	true	Temperature description
valuation	integer	true	Market valuation
sentiment	integer	true	Market sentiment
updated_at	integer	true	Update time

Error Codes

Business Error Code	Description	Troubleshooting
2601500	Server Internal Error	Please retry or contact technical support