# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hszg/list/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.concept_tree()
    print(data)

对应 SDK v1.2.0 · 方法 api.concept_tree · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hszg/list/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.concept_tree();
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.concept_tree · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hszg/list/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.conceptTree();
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.conceptTree · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hszg/list/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.ConceptTree()
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.ConceptTree · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hszg/list/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.ConceptTreeAsync();
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.ConceptTreeAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hszg/gg/指数、行业、概念代码/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.stocks_of_concept("sw_sysh")
    print(data)

对应 SDK v1.2.0 · 方法 api.stocks_of_concept · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hszg/gg/指数、行业、概念代码/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.stocks_of_concept("sw_sysh");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.stocks_of_concept · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hszg/gg/指数、行业、概念代码/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.stocksOfConcept("sw_sysh");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.stocksOfConcept · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hszg/gg/指数、行业、概念代码/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.StocksOfConcept("sw_sysh")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.StocksOfConcept · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hszg/gg/指数、行业、概念代码/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.StocksOfConceptAsync("sw_sysh");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.StocksOfConceptAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hszg/zg/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.concepts_of_stock("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.concepts_of_stock · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hszg/zg/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.concepts_of_stock("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.concepts_of_stock · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hszg/zg/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.conceptsOfStock("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.conceptsOfStock · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hszg/zg/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.ConceptsOfStock("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.ConceptsOfStock · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hszg/zg/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.ConceptsOfStockAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.ConceptsOfStockAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hslt/ztgc/日期(如2020-01-15)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.limit_up_pool("2024-01-10")
    print(data)

对应 SDK v1.2.0 · 方法 api.limit_up_pool · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hslt/ztgc/日期(如2020-01-15)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.limit_up_pool("2024-01-10");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.limit_up_pool · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hslt/ztgc/日期(如2020-01-15)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.limitUpPool("2024-01-10");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.limitUpPool · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hslt/ztgc/日期(如2020-01-15)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.LimitUpPool("2024-01-10")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.LimitUpPool · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hslt/ztgc/日期(如2020-01-15)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.LimitUpPoolAsync("2024-01-10");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.LimitUpPoolAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hslt/dtgc/日期(如2020-01-15)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.limit_down_pool("2024-01-10")
    print(data)

对应 SDK v1.2.0 · 方法 api.limit_down_pool · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hslt/dtgc/日期(如2020-01-15)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.limit_down_pool("2024-01-10");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.limit_down_pool · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hslt/dtgc/日期(如2020-01-15)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.limitDownPool("2024-01-10");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.limitDownPool · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hslt/dtgc/日期(如2020-01-15)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.LimitDownPool("2024-01-10")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.LimitDownPool · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hslt/dtgc/日期(如2020-01-15)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.LimitDownPoolAsync("2024-01-10");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.LimitDownPoolAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hslt/qsgc/日期(如2020-01-15)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.strong_pool("2024-01-10")
    print(data)

对应 SDK v1.2.0 · 方法 api.strong_pool · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hslt/qsgc/日期(如2020-01-15)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.strong_pool("2024-01-10");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.strong_pool · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hslt/qsgc/日期(如2020-01-15)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.strongPool("2024-01-10");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.strongPool · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hslt/qsgc/日期(如2020-01-15)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.StrongPool("2024-01-10")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.StrongPool · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hslt/qsgc/日期(如2020-01-15)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.StrongPoolAsync("2024-01-10");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.StrongPoolAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hslt/cxgc/日期(如2020-01-15)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.new_stock_pool("2024-01-10")
    print(data)

对应 SDK v1.2.0 · 方法 api.new_stock_pool · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hslt/cxgc/日期(如2020-01-15)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.new_stock_pool("2024-01-10");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.new_stock_pool · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hslt/cxgc/日期(如2020-01-15)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.newStockPool("2024-01-10");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.newStockPool · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hslt/cxgc/日期(如2020-01-15)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.NewStockPool("2024-01-10")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.NewStockPool · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hslt/cxgc/日期(如2020-01-15)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.NewStockPoolAsync("2024-01-10");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.NewStockPoolAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hslt/zbgc/日期(如2020-01-15)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.broken_board_pool("2024-01-10")
    print(data)

对应 SDK v1.2.0 · 方法 api.broken_board_pool · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hslt/zbgc/日期(如2020-01-15)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.broken_board_pool("2024-01-10");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.broken_board_pool · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hslt/zbgc/日期(如2020-01-15)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.brokenBoardPool("2024-01-10");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.brokenBoardPool · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hslt/zbgc/日期(如2020-01-15)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.BrokenBoardPool("2024-01-10")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.BrokenBoardPool · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hslt/zbgc/日期(如2020-01-15)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.BrokenBoardPoolAsync("2024-01-10");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.BrokenBoardPoolAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hscp/gsjj/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.company_profile("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.company_profile · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hscp/gsjj/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.company_profile("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.company_profile · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hscp/gsjj/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.companyProfile("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.companyProfile · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hscp/gsjj/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.CompanyProfile("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.CompanyProfile · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hscp/gsjj/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.CompanyProfileAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.CompanyProfileAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hscp/sszs/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.company_indexes("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.company_indexes · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hscp/sszs/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.company_indexes("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.company_indexes · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hscp/sszs/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.companyIndexes("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.companyIndexes · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hscp/sszs/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.CompanyIndexes("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.CompanyIndexes · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hscp/sszs/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.CompanyIndexesAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.CompanyIndexesAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hscp/ljgg/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.company_executives("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.company_executives · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hscp/ljgg/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.company_executives("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.company_executives · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hscp/ljgg/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.companyExecutives("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.companyExecutives · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hscp/ljgg/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.CompanyExecutives("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.CompanyExecutives · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hscp/ljgg/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.CompanyExecutivesAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.CompanyExecutivesAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hscp/ljds/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.company_directors("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.company_directors · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hscp/ljds/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.company_directors("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.company_directors · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hscp/ljds/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.companyDirectors("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.companyDirectors · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hscp/ljds/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.CompanyDirectors("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.CompanyDirectors · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hscp/ljds/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.CompanyDirectorsAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.CompanyDirectorsAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hscp/ljjj/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.company_supervisors("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.company_supervisors · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hscp/ljjj/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.company_supervisors("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.company_supervisors · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hscp/ljjj/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.companySupervisors("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.companySupervisors · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hscp/ljjj/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.CompanySupervisors("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.CompanySupervisors · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hscp/ljjj/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.CompanySupervisorsAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.CompanySupervisorsAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hscp/jnfh/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.company_dividends("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.company_dividends · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hscp/jnfh/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.company_dividends("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.company_dividends · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hscp/jnfh/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.companyDividends("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.companyDividends · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hscp/jnfh/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.CompanyDividends("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.CompanyDividends · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hscp/jnfh/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.CompanyDividendsAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.CompanyDividendsAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hscp/jnzf/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.company_seo("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.company_seo · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hscp/jnzf/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.company_seo("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.company_seo · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hscp/jnzf/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.companySeo("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.companySeo · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hscp/jnzf/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.CompanySeo("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.CompanySeo · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hscp/jnzf/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.CompanySeoAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.CompanySeoAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hscp/jjxs/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.company_unlock("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.company_unlock · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hscp/jjxs/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.company_unlock("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.company_unlock · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hscp/jjxs/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.companyUnlock("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.companyUnlock · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hscp/jjxs/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.CompanyUnlock("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.CompanyUnlock · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hscp/jjxs/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.CompanyUnlockAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.CompanyUnlockAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hscp/jdlr/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.company_quarter_profit("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.company_quarter_profit · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hscp/jdlr/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.company_quarter_profit("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.company_quarter_profit · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hscp/jdlr/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.companyQuarterProfit("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.companyQuarterProfit · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hscp/jdlr/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.CompanyQuarterProfit("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.CompanyQuarterProfit · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hscp/jdlr/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.CompanyQuarterProfitAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.CompanyQuarterProfitAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hscp/jdxj/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.company_quarter_cashflow("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.company_quarter_cashflow · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hscp/jdxj/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.company_quarter_cashflow("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.company_quarter_cashflow · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hscp/jdxj/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.companyQuarterCashflow("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.companyQuarterCashflow · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hscp/jdxj/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.CompanyQuarterCashflow("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.CompanyQuarterCashflow · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hscp/jdxj/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.CompanyQuarterCashflowAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.CompanyQuarterCashflowAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hscp/yjyg/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.company_earnings_forecast("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.company_earnings_forecast · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hscp/yjyg/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.company_earnings_forecast("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.company_earnings_forecast · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hscp/yjyg/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.companyEarningsForecast("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.companyEarningsForecast · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hscp/yjyg/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.CompanyEarningsForecast("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.CompanyEarningsForecast · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hscp/yjyg/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.CompanyEarningsForecastAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.CompanyEarningsForecastAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hscp/cwzb/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.company_financial_index("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.company_financial_index · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hscp/cwzb/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.company_financial_index("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.company_financial_index · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hscp/cwzb/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.companyFinancialIndex("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.companyFinancialIndex · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hscp/cwzb/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.CompanyFinancialIndex("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.CompanyFinancialIndex · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hscp/cwzb/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.CompanyFinancialIndexAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.CompanyFinancialIndexAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hscp/sdgd/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.company_top10_holders("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.company_top10_holders · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hscp/sdgd/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.company_top10_holders("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.company_top10_holders · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hscp/sdgd/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.companyTop10Holders("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.companyTop10Holders · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hscp/sdgd/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.CompanyTop10Holders("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.CompanyTop10Holders · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hscp/sdgd/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.CompanyTop10HoldersAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.CompanyTop10HoldersAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hscp/ltgd/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.company_top10_float_holders("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.company_top10_float_holders · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hscp/ltgd/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.company_top10_float_holders("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.company_top10_float_holders · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hscp/ltgd/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.companyTop10FloatHolders("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.companyTop10FloatHolders · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hscp/ltgd/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.CompanyTop10FloatHolders("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.CompanyTop10FloatHolders · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hscp/ltgd/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.CompanyTop10FloatHoldersAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.CompanyTop10FloatHoldersAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hscp/gdbh/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.company_holder_change("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.company_holder_change · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hscp/gdbh/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.company_holder_change("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.company_holder_change · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hscp/gdbh/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.companyHolderChange("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.companyHolderChange · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hscp/gdbh/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.CompanyHolderChange("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.CompanyHolderChange · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hscp/gdbh/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.CompanyHolderChangeAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.CompanyHolderChangeAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hscp/jjcg/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.company_fund_holding("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.company_fund_holding · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hscp/jjcg/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.company_fund_holding("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.company_fund_holding · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hscp/jjcg/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.companyFundHolding("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.companyFundHolding · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hscp/jjcg/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.CompanyFundHolding("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.CompanyFundHolding · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hscp/jjcg/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.CompanyFundHoldingAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.CompanyFundHoldingAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hsrl/ssjy/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.stock_ssjy("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.stock_ssjy · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hsrl/ssjy/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.stock_ssjy("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.stock_ssjy · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hsrl/ssjy/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.stockSsjy("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.stockSsjy · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hsrl/ssjy/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.StockSsjy("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.StockSsjy · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hsrl/ssjy/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.StockSsjyAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.StockSsjyAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hsrl/zbjy/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.stock_zbjy("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.stock_zbjy · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hsrl/zbjy/股票代码(如000001)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.stock_zbjy("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.stock_zbjy · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hsrl/zbjy/股票代码(如000001)/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.stockZbjy("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.stockZbjy · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hsrl/zbjy/股票代码(如000001)/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.StockZbjy("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.StockZbjy · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hsrl/zbjy/股票代码(如000001)/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.StockZbjyAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.StockZbjyAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hsstock/real/time/股票代码/证书您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.stock_real_time("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.stock_real_time · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hsstock/real/time/股票代码/证书您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.stock_real_time("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.stock_real_time · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hsstock/real/time/股票代码/证书您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.stockRealTime("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.stockRealTime · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hsstock/real/time/股票代码/证书您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.StockRealTime("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.StockRealTime · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hsstock/real/time/股票代码/证书您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.StockRealTimeAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.StockRealTimeAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hsstock/real/five/股票代码/证书您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.stock_real_five("000001")
    print(data)

对应 SDK v1.2.0 · 方法 api.stock_real_five · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hsstock/real/five/股票代码/证书您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.stock_real_five("000001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.stock_real_five · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hsstock/real/five/股票代码/证书您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.stockRealFive("000001");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.stockRealFive · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hsstock/real/five/股票代码/证书您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.StockRealFive("000001")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.StockRealFive · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hsstock/real/five/股票代码/证书您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.StockRealFiveAsync("000001");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.StockRealFiveAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hsrl/ssjy/all/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.stock_ssjy_all()
    print(data)

对应 SDK v1.2.0 · 方法 api.stock_ssjy_all · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hsrl/ssjy/all/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.stock_ssjy_all();
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.stock_ssjy_all · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hsrl/ssjy/all/您的licence".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.stockSsjyAll();
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.stockSsjyAll · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hsrl/ssjy/all/您的licence', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.StockSsjyAll()
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.StockSsjyAll · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hsrl/ssjy/all/您的licence".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.StockSsjyAllAsync();
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.StockSsjyAllAsync · 安装与对照

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hsrl/ssjy_more/您的licence?stock_codes=股票代码1,股票代码2……股票代码20'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

from mairui import Client

with Client(licence="您的licence") as api:
    data = api.stock_ssjy_more("000001,000002,000004")
    print(data)

对应 SDK v1.2.0 · 方法 api.stock_ssjy_more · 安装与对照

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hsrl/ssjy_more/您的licence?stock_codes=股票代码1,股票代码2……股票代码20'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

import { Client } from "@mairuiapi/mairui";

const api = new Client({ licence: "您的licence" });
const data = await api.stock_ssjy_more("000001,000002,000004");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.stock_ssjy_more · 安装与对照

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class MairuiDemo {
  public static void main(String[] args) throws Exception {
    String licence = "YOUR-LICENCE";
    String url = "https://api.mairuiapi.com/hsrl/ssjy_more/您的licence?stock_codes=股票代码1,股票代码2……股票代码20".replace("YOUR-LICENCE", licence);
    HttpRequest req = HttpRequest.newBuilder(URI.create(url)).GET().build();
    HttpResponse<String> resp = HttpClient.newHttpClient()
        .send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(resp.statusCode());
    System.out.println(resp.body());
  }
}

import com.mairui.MairuiClient;

MairuiClient api = new MairuiClient("您的licence");
Object data = api.stockSsjyMore("000001,000002,000004");
System.out.println(data);
api.close();

对应 SDK v1.2.0 · 方法 api.stockSsjyMore · 安装与对照

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hsrl/ssjy_more/您的licence?stock_codes=股票代码1,股票代码2……股票代码20', "YOUR-LICENCE", licence)
  resp, err := http.Get(url)
  if err != nil { panic(err) }
  defer resp.Body.Close()
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(resp.StatusCode)
  fmt.Println(string(body))
}

package main

import (
	"fmt"
	"github.com/MaiRuiApi/mairui-go"
)

func main() {
	api, _ := mairui.NewClient(mairui.ClientOptions{Licence: "您的licence"})
	defer api.Close()
	data, _ := api.StockSsjyMore("000001,000002,000004")
	fmt.Println(data)
}

对应 SDK v1.2.0 · 方法 api.StockSsjyMore · 安装与对照

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program {
  static async Task Main() {
    var licence = "YOUR-LICENCE";
    var url = "https://api.mairuiapi.com/hsrl/ssjy_more/您的licence?stock_codes=股票代码1,股票代码2……股票代码20".Replace("YOUR-LICENCE", licence);
    using var http = new HttpClient();
    var resp = await http.GetAsync(url);
    Console.WriteLine((int)resp.StatusCode);
    Console.WriteLine(await resp.Content.ReadAsStringAsync());
  }
}

using MairuiSdk;

var api = new MairuiClient("您的licence");
var data = await api.StockSsjyMoreAsync("000001,000002,000004");
Console.WriteLine(data);

对应 SDK v1.2.0 · 方法 api.StockSsjyMoreAsync · 安装与对照