# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hilh/mrxq/您的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.hsdc_hilh_mrxq()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hilh/mrxq/您的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.hsdc_hilh_mrxq();
console.log(data);
api.close();

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

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/hilh/mrxq/您的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.hsdcHilhMrxq();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hilh/mrxq/您的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.HsdcHilhMrxq()
	fmt.Println(data)
}

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

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/hilh/mrxq/您的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.HsdcHilhMrxqAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hilh/ggsb/近几日(如5)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hilh/ggsb/近几日(如5)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hilh/ggsb/近几日(如5)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hilh/ggsb/近几日(如5)/您的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))
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hilh/ggsb/近几日(如5)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hilh/yybsb/近几日(如5)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hilh/yybsb/近几日(如5)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hilh/yybsb/近几日(如5)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hilh/yybsb/近几日(如5)/您的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))
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hilh/yybsb/近几日(如5)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hilh/jgxw/近几日(如5)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hilh/jgxw/近几日(如5)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hilh/jgxw/近几日(如5)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hilh/jgxw/近几日(如5)/您的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))
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hilh/jgxw/近几日(如5)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hilh/xwmx/您的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.hsdc_hilh_xwmx()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hilh/xwmx/您的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.hsdc_hilh_xwmx();
console.log(data);
api.close();

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

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/hilh/xwmx/您的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.hsdcHilhXwmx();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hilh/xwmx/您的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.HsdcHilhXwmx()
	fmt.Println(data)
}

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

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/hilh/xwmx/您的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.HsdcHilhXwmxAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/himk/jdzgzd/您的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.hsdc_himk_jdzgzd()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/himk/jdzgzd/您的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.hsdc_himk_jdzgzd();
console.log(data);
api.close();

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

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/himk/jdzgzd/您的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.hsdcHimkJdzgzd();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/himk/jdzgzd/您的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.HsdcHimkJdzgzd()
	fmt.Println(data)
}

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

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/himk/jdzgzd/您的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.HsdcHimkJdzgzdAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/himk/pzxg/您的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.hsdc_himk_pzxg()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/himk/pzxg/您的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.hsdc_himk_pzxg();
console.log(data);
api.close();

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

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/himk/pzxg/您的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.hsdcHimkPzxg();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/himk/pzxg/您的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.HsdcHimkPzxg()
	fmt.Println(data)
}

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

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/himk/pzxg/您的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.HsdcHimkPzxgAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/himk/pzxd/您的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.hsdc_himk_pzxd()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/himk/pzxd/您的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.hsdc_himk_pzxd();
console.log(data);
api.close();

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

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/himk/pzxd/您的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.hsdcHimkPzxd();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/himk/pzxd/您的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.HsdcHimkPzxd()
	fmt.Println(data)
}

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

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/himk/pzxd/您的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.HsdcHimkPzxdAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/himk/cjzz/您的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.hsdc_himk_cjzz()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/himk/cjzz/您的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.hsdc_himk_cjzz();
console.log(data);
api.close();

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

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/himk/cjzz/您的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.hsdcHimkCjzz();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/himk/cjzz/您的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.HsdcHimkCjzz()
	fmt.Println(data)
}

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

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/himk/cjzz/您的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.HsdcHimkCjzzAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/himk/cjzj/您的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.hsdc_himk_cjzj()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/himk/cjzj/您的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.hsdc_himk_cjzj();
console.log(data);
api.close();

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

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/himk/cjzj/您的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.hsdcHimkCjzj();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/himk/cjzj/您的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.HsdcHimkCjzj()
	fmt.Println(data)
}

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

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/himk/cjzj/您的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.HsdcHimkCjzjAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/himk/lxfl/您的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.hsdc_himk_lxfl()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/himk/lxfl/您的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.hsdc_himk_lxfl();
console.log(data);
api.close();

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

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/himk/lxfl/您的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.hsdcHimkLxfl();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/himk/lxfl/您的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.HsdcHimkLxfl()
	fmt.Println(data)
}

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

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/himk/lxfl/您的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.HsdcHimkLxflAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/himk/lxsl/您的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.hsdc_himk_lxsl()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/himk/lxsl/您的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.hsdc_himk_lxsl();
console.log(data);
api.close();

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

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/himk/lxsl/您的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.hsdcHimkLxsl();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/himk/lxsl/您的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.HsdcHimkLxsl()
	fmt.Println(data)
}

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

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/himk/lxsl/您的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.HsdcHimkLxslAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/himk/lxsz/您的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.hsdc_himk_lxsz()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/himk/lxsz/您的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.hsdc_himk_lxsz();
console.log(data);
api.close();

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

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/himk/lxsz/您的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.hsdcHimkLxsz();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/himk/lxsz/您的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.HsdcHimkLxsz()
	fmt.Println(data)
}

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

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/himk/lxsz/您的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.HsdcHimkLxszAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/himk/lxxd/您的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.hsdc_himk_lxxd()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/himk/lxxd/您的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.hsdc_himk_lxxd();
console.log(data);
api.close();

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

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/himk/lxxd/您的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.hsdcHimkLxxd();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/himk/lxxd/您的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.HsdcHimkLxxd()
	fmt.Println(data)
}

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

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/himk/lxxd/您的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.HsdcHimkLxxdAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/himk/zzd/您的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.hsdc_himk_zzd()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/himk/zzd/您的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.hsdc_himk_zzd();
console.log(data);
api.close();

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

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/himk/zzd/您的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.hsdcHimkZzd();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/himk/zzd/您的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.HsdcHimkZzd()
	fmt.Println(data)
}

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

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/himk/zzd/您的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.HsdcHimkZzdAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/himk/yzd/您的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.hsdc_himk_yzd()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/himk/yzd/您的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.hsdc_himk_yzd();
console.log(data);
api.close();

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

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/himk/yzd/您的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.hsdcHimkYzd();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/himk/yzd/您的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.HsdcHimkYzd()
	fmt.Println(data)
}

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

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/himk/yzd/您的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.HsdcHimkYzdAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/himk/ltszph/您的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.hsdc_himk_ltszph()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/himk/ltszph/您的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.hsdc_himk_ltszph();
console.log(data);
api.close();

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

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/himk/ltszph/您的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.hsdcHimkLtszph();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/himk/ltszph/您的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.HsdcHimkLtszph()
	fmt.Println(data)
}

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

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/himk/ltszph/您的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.HsdcHimkLtszphAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/himk/syl/您的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.hsdc_himk_syl()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/himk/syl/您的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.hsdc_himk_syl();
console.log(data);
api.close();

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

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/himk/syl/您的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.hsdcHimkSyl();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/himk/syl/您的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.HsdcHimkSyl()
	fmt.Println(data)
}

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

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/himk/syl/您的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.HsdcHimkSylAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/himk/sjl/您的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.hsdc_himk_sjl()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/himk/sjl/您的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.hsdc_himk_sjl();
console.log(data);
api.close();

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

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/himk/sjl/您的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.hsdcHimkSjl();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/himk/sjl/您的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.HsdcHimkSjl()
	fmt.Println(data)
}

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

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/himk/sjl/您的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.HsdcHimkSjlAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/himk/roe/您的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.hsdc_himk_roe()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/himk/roe/您的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.hsdc_himk_roe();
console.log(data);
api.close();

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

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/himk/roe/您的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.hsdcHimkRoe();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/himk/roe/您的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.HsdcHimkRoe()
	fmt.Println(data)
}

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

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/himk/roe/您的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.HsdcHimkRoeAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hicw/yl/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hicw/yl/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hicw/yl/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hicw/yl/年度(如2020)/季度(如1)/您的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))
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hicw/yl/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hicw/yy/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hicw/yy/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hicw/yy/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hicw/yy/年度(如2020)/季度(如1)/您的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))
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hicw/yy/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hicw/cz/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hicw/cz/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hicw/cz/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hicw/cz/年度(如2020)/季度(如1)/您的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))
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hicw/cz/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hicw/cznl/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hicw/cznl/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hicw/cznl/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hicw/cznl/年度(如2020)/季度(如1)/您的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))
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hicw/cznl/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hicw/xj/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hicw/xj/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hicw/xj/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hicw/xj/年度(如2020)/季度(如1)/您的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))
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hicw/xj/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hicw/yjbb/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hicw/yjbb/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hicw/yjbb/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hicw/yjbb/年度(如2020)/季度(如1)/您的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))
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hicw/yjbb/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hicw/yjyg/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hicw/yjyg/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hicw/yjyg/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hicw/yjyg/年度(如2020)/季度(如1)/您的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))
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hicw/yjyg/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hicw/yjkb/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hicw/yjkb/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hicw/yjkb/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hicw/yjkb/年度(如2020)/季度(如1)/您的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))
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hicw/yjkb/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hicw/lr/您的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.hsdc_hicw_lr()
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hicw/lr/您的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.hsdc_hicw_lr();
console.log(data);
api.close();

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

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/hicw/lr/您的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.hsdcHicwLr();
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hicw/lr/您的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.HsdcHicwLr()
	fmt.Println(data)
}

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

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/hicw/lr/您的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.HsdcHicwLrAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/hijg/jgcghz/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", LICENCE)
resp = requests.get(url, timeout=15)
print(resp.status_code)
print(resp.json())

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/hijg/jgcghz/年度(如2020)/季度(如1)/您的licence'.replace("YOUR-LICENCE", licence);
const resp = await fetch(url);
console.log(resp.status);
console.log(await resp.json());

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hijg/jgcghz/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/hijg/jgcghz/年度(如2020)/季度(如1)/您的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))
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK

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/hijg/jgcghz/年度(如2020)/季度(如1)/您的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());
  }
}

当前接口在官方多语言 SDK（v1.2.0）中暂无专用方法封装，请使用本页「HTTP 请求」方式调用；鉴权与限流规则与 SDK 完全一致。

了解多语言 SDK