Create Watchlist Group

Create watched group

SDK Links

Python	longbridge.openapi.QuoteContext.create_watchlist_group
Rust	longbridge::quote::QuoteContext#create_watchlist_group
Go	QuoteContext.CreateWatchlistGroup
Node.js	QuoteContext#createWatchlistGroup
Java	QuoteContext.createWatchlistGroup
C++	longbridge::quote::QuoteContext::create_watchlist_group

Request

HTTP Method	POST
HTTP URL	/v1/watchlist/groups

Parameters

Content-Type: application/json; charset=utf-8

Name	Type	Required	Description
name	string	YES	Group name, for example Information Technology Group.
securities	string[]	NO	Security list, for example ["BABA.US", "AAPL.US"]. Display order of securities in the group, in the same order as this list. If this parameter is not passed, create an empty group.

Request Example

from longbridge.openapi import QuoteContext, Config, OAuthBuilder

oauth = OAuthBuilder("your-client-id").build(lambda url: print("Visit:", url))
config = Config.from_oauth(oauth)
ctx = QuoteContext(config)
group_id = ctx.create_watchlist_group(name = "Watchlist1", securities = ["700.HK", "AAPL.US"])
print(group_id)

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

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 = await QuoteContext.new(config)
  const resp = await ctx.createWatchlistGroup("My Group", ["700.HK", "AAPL.US"])
  console.log(resp)
}
main().catch(console.error)

import com.longbridge.*;
import com.longbridge.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).get()) {
            WatchlistGroup resp = ctx.createWatchlistGroup("My Group", new String[] { "700.HK", "AAPL.US" }).get();
            System.out.println(resp);
        }
    }
}

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

#[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::try_new(config).await?;
    let resp = ctx.create_watchlist_group("My Group", vec!["700.HK".to_string(), "AAPL.US".to_string()]).await?;
    println!("{:?}", resp);
    Ok(())
}

#include <iostream>
#include <longbridge.hpp>
#ifdef WIN32
#include <windows.h>
#endif
using namespace longbridge;
using namespace longbridge::quote;

int main(int argc, char const* argv[]) {
#ifdef WIN32
  SetConsoleOutputCP(CP_UTF8);
#endif
  const std::string client_id = "your-client-id";
  std::vector<std::string> symbols = {"700.HK", "AAPL.US"};
  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" << std::endl; return; }
      Config config = Config::from_oauth(*res);
      QuoteContext::create(config, [](auto res) {
        if (!res) { std::cout << "failed to create quote context" << std::endl; return; }
        res.context().create_watchlist_group("My Group", symbols, [](auto res) {
          if (!res) { std::cout << "failed" << std::endl; return; }
          std::cout << "created: " << res->name << std::endl;
        });
      });
    });
  std::cin.get();
  return 0;
}

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/longbridge/openapi-go/config"
	"github.com/longbridge/openapi-go/oauth"
	"github.com/longbridge/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()
	gid, err := qctx.CreateWatchlistGroup(context.Background(), "My Group", []string{"700.HK", "AAPL.US"})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("created:", gid)
}

Response

Response Headers

• Content-Type: application/json

Response Example

{
  "code": 0,
  "data": {
    "id": 10086
  }
}

Response Status

Status	Description	Schema
200	Success	create_group_response
500	Internal error	None

Schemas

create_group_response

Name	Type	Required	Description
id	integer	false	Group ID