# pip install mairui  或使用 requests
import requests

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

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

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

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

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/js/pm/kfpm/kfsjj_gpxjj_zsx/您的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.fundcPmKfpm();
System.out.println(data);
api.close();

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

package main

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

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

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

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/js/pm/kfpm/kfsjj_gpxjj_zsx/您的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.FundcPmKfpmAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

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

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

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

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

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/js/pm/fbpm/kfsjj_fbqy_ctfj/您的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.fundcPmFbpm();
System.out.println(data);
api.close();

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

package main

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

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

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

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/js/pm/fbpm/kfsjj_fbqy_ctfj/您的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.FundcPmFbpmAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

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

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

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

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

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/js/pm/fzyj/kfsjj_fjgs_wjzqx/您的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.fundcPmFzyj();
System.out.println(data);
api.close();

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

package main

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

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

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

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/js/pm/fzyj/kfsjj_fjgs_wjzqx/您的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.FundcPmFzyjAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

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

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

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

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

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/js/jf/kffh/kfsjj_gpxjj_zsx/您的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.fundcJfKffh();
System.out.println(data);
api.close();

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

package main

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

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

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

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/js/jf/kffh/kfsjj_gpxjj_zsx/您的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.FundcJfKffhAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

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

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

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

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

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/js/jf/fzfh/kfsjj_fjgs_wjzqx/您的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.fundcJfFzfh();
System.out.println(data);
api.close();

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

package main

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

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

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

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/js/jf/fzfh/kfsjj_fjgs_wjzqx/您的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.FundcJfFzfhAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

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

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

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

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

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/js/gm/kfgm/kfsjj_gpxjj_zsx/您的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.fundcGmKfgm();
System.out.println(data);
api.close();

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

package main

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

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

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

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/js/gm/kfgm/kfsjj_gpxjj_zsx/您的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.FundcGmKfgmAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

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

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

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

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

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/js/gm/fbgm/kfsjj_fbqy_ctfj/您的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.fundcGmFbgm();
System.out.println(data);
api.close();

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

package main

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

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

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

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/js/gm/fbgm/kfsjj_fbqy_ctfj/您的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.FundcGmFbgmAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

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

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

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

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

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/js/gm/fzgm/kfsjj_fjgs_wjzqx/您的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.fundcGmFzgm();
System.out.println(data);
api.close();

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

package main

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

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

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

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/js/gm/fzgm/kfsjj_fjgs_wjzqx/您的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.FundcGmFzgmAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/js/other/jjzc/2026_2/您的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/js/other/jjzc/2026_2/您的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/js/other/jjzc/2026_2/您的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/js/other/jjzc/2026_2/您的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/js/other/jjzc/2026_2/您的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/js/other/zcbd/2026_2/您的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/js/other/zcbd/2026_2/您的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/js/other/zcbd/2026_2/您的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/js/other/zcbd/2026_2/您的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/js/other/zcbd/2026_2/您的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/js/other/dxjg/yh/您的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.fundc_other_dxjg()
    print(data)

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

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

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

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/js/other/dxjg/yh/您的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.fundcOtherDxjg();
System.out.println(data);
api.close();

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

package main

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

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

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

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/js/other/dxjg/yh/您的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.FundcOtherDxjgAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

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

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/fd/list/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.fund_list();
console.log(data);
api.close();

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

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/fd/list/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.fundList();
System.out.println(data);
api.close();

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

package main

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

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

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

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/fd/list/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.FundListAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

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

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

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

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

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/fd/list/etf/您的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.etfList();
System.out.println(data);
api.close();

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

package main

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

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

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

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/fd/list/etf/您的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.EtfListAsync();
Console.WriteLine(data);

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

# pip install mairui  或使用 requests
import requests

LICENCE = "YOUR-LICENCE"  # 替换为您的证书
url = 'https://api.mairuiapi.com/fd/real/time/基金代码(如159001)/您的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.fund_real_time("159001")
    print(data)

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

const licence = "YOUR-LICENCE";
const url = 'https://api.mairuiapi.com/fd/real/time/基金代码(如159001)/您的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.fund_real_time("159001");
console.log(data);
api.close();

对应 SDK v1.2.0 · 方法 api.fund_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/fd/real/time/基金代码(如159001)/您的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.fundRealTime("159001");
System.out.println(data);
api.close();

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

package main

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

func main() {
  licence := "YOUR-LICENCE"
  url := strings.ReplaceAll('https://api.mairuiapi.com/fd/real/time/基金代码(如159001)/您的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.FundRealTime("159001")
	fmt.Println(data)
}

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

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/fd/real/time/基金代码(如159001)/您的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.FundRealTimeAsync("159001");
Console.WriteLine(data);

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