Web Search API

本接口提供统一的 Web Search 能力，通过 engine 参数选择不同引擎。

API 接口及请求方式

https://search.aiserver.cloud/v1/api

请求方式：POST

请求头

方式	说明
Header	`Authorization: Bearer <API_KEY>`

在控制台获取你的 API Key。

请求参数

字段	类型	必填	说明
`engine`	string	否	`china`（中国区）或 `global`（全球），默认 `china`
`query`	string	是	搜索词，支持自然语言，建议 ≤ 500 字符
`max_results`	number	否	返回条数，范围 1-20，默认 10
`time_filter`	string	否	时间过滤：`day`（1 天内） / `week`（1 周内） / `month`（1 个月内） / `year`（1 年内）
`include_domains`	string[]	否	指定搜索的网站范围，多个需要用`,`隔开（最多 20 个有效域名）如：`["example.com", "google.com", "baidu.cn"]`
`exclude_domains`	string[]	否	排除搜索的网站范围，多个需要用`,`隔开（最多 20 个有效域名）如：`["example.com", "google.com", "baidu.cn"]`

响应结构

{
  "code": 0,
  "msg": "",
  "engine": "china",
  "balance": {
    "times": { "china": 990, "global": 1000 },
    "amount": 100.0
  },
  "log_id": "LOG202412271234abcdef",
  "searchParams": {
    "engine": "china",
    "query": "搜索词",
    "max_results": 10,
    "time_filter": "",
    "include_domains": [],
    "exclude_domains": []
  },
  "data": {
    "images": [{ "url": "https://example.com/image.jpg" }],
    "results": [
      {
        "title": "页面标题",
        "url": "https://example.com/page",
        "content": "页面摘要内容..."
      }
    ]
  }
}

响应字段说明

字段	类型	说明
`code`	number	状态码，`0` 表示成功，其他都是失败(详细请查看错误码)
`msg`	string	错误信息（成功时为空）
`engine`	string	本次使用的引擎
`balance.times`	object	剩余套餐次数（按引擎）
`balance.amount`	number	账户余额
`log_id`	string	本次请求的日志 ID
`searchParams`	object	本次实际使用的搜索参数
`data.images`	array	相关图片列表
`data.results`	array	搜索结果列表

results 结构

字段	类型	说明
`title`	string	页面标题
`url`	string	页面链接
`content`	string	页面摘要/内容片段

images 结构

字段	类型	说明
`url`	string	图片链接

请求示例

提示

以下示例展示了不同编程语言和不同搜索参数组合的使用方法。所有示例都需要替换 Your-API-KEY 为你的真实 API Key。

示例 1：基础搜索（仅必需参数）

使用默认配置，只需提供搜索关键词。

cURL

curl --location 'https://search.aiserver.cloud/v1/api' \
  --header 'Authorization: Bearer Your-API-KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "query": "人工智能"
  }'

Python

import requests

url = "https://search.aiserver.cloud/v1/api"
headers = {
    "Authorization": "Bearer Your-API-KEY",
    "Content-Type": "application/json"
}
payload = {
    "query": "人工智能"
}

response = requests.post(url, headers=headers, json=payload)
data = response.json()
print(data)

JavaScript

fetch('https://search.aiserver.cloud/v1/api', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer Your-API-KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    query: '人工智能'
  })
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

TypeScript

interface SearchRequest {
  query: string;
  engine?: 'china' | 'global';
  max_results?: number;
  time_filter?: 'day' | 'week' | 'month' | 'year';
  include_domains?: string[];
  exclude_domains?: string[];
}

async function search(params: SearchRequest) {
  const response = await fetch('https://search.aiserver.cloud/v1/api', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer Your-API-KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(params)
  });
  
  return await response.json();
}

// 使用示例
search({ query: '人工智能' })
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import org.json.JSONObject;

public class WebSearchExample {
    public static void main(String[] args) throws Exception {
        String url = "https://search.aiserver.cloud/v1/api";
        
        JSONObject payload = new JSONObject();
        payload.put("query", "人工智能");
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer Your-API-KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload.toString()))
            .build();
        
        HttpResponse<String> response = client.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        System.out.println(response.body());
    }
}

PHP

<?php

$url = 'https://search.aiserver.cloud/v1/api';
$headers = [
    'Authorization: Bearer Your-API-KEY',
    'Content-Type: application/json'
];

$data = [
    'query' => '人工智能'
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);

?>

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "https://search.aiserver.cloud/v1/api"
    
    payload := map[string]interface{}{
        "query": "人工智能",
    }
    
    jsonData, _ := json.Marshal(payload)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer Your-API-KEY")
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Ruby

require 'net/http'
require 'json'
require 'uri'

url = URI('https://search.aiserver.cloud/v1/api')
headers = {
  'Authorization' => 'Bearer Your-API-KEY',
  'Content-Type' => 'application/json'
}

data = {
  query: '人工智能'
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url, headers)
request.body = data.to_json

response = http.request(request)
result = JSON.parse(response.body)

puts JSON.pretty_generate(result)

示例 2：指定引擎 + 结果数量

使用中国区引擎，返回 15 条结果。

cURL

curl --location 'https://search.aiserver.cloud/v1/api' \
  --header 'Authorization: Bearer Your-API-KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "engine": "china",
    "query": "量子计算",
    "max_results": 15
  }'

Python

import requests

response = requests.post(
    'https://search.aiserver.cloud/v1/api',
    headers={
        'Authorization': 'Bearer Your-API-KEY',
        'Content-Type': 'application/json'
    },
    json={
        'engine': 'china',
        'query': '量子计算',
        'max_results': 15
    }
)

print(response.json())

JavaScript

fetch('https://search.aiserver.cloud/v1/api', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer Your-API-KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    engine: 'china',
    query: '量子计算',
    max_results: 15
  })
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

TypeScript

interface SearchRequest {
  engine?: 'china' | 'global';
  query: string;
  max_results?: number;
  time_filter?: 'day' | 'week' | 'month' | 'year';
  include_domains?: string[];
  exclude_domains?: string[];
}

async function search(params: SearchRequest) {
  const response = await fetch('https://search.aiserver.cloud/v1/api', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer Your-API-KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(params)
  });
  
  return await response.json();
}

// 使用示例
search({
  engine: 'china',
  query: '量子计算',
  max_results: 15
}).then(data => console.log(data));

PHP

<?php

$url = 'https://search.aiserver.cloud/v1/api';
$headers = [
    'Authorization: Bearer Your-API-KEY',
    'Content-Type: application/json'
];

$data = [
    'engine' => 'china',
    'query' => '量子计算',
    'max_results' => 15
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);

?>

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "https://search.aiserver.cloud/v1/api"
    
    payload := map[string]interface{}{
        "engine": "china",
        "query": "量子计算",
        "max_results": 15,
    }
    
    jsonData, _ := json.Marshal(payload)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer Your-API-KEY")
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Ruby

require 'net/http'
require 'json'
require 'uri'

url = URI('https://search.aiserver.cloud/v1/api')
headers = {
  'Authorization' => 'Bearer Your-API-KEY',
  'Content-Type' => 'application/json'
}

data = {
  engine: 'china',
  query: '量子计算',
  max_results: 15
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url, headers)
request.body = data.to_json

response = http.request(request)
result = JSON.parse(response.body)

puts JSON.pretty_generate(result)

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import org.json.JSONObject;

public class WebSearchExample {
    public static void main(String[] args) throws Exception {
        String url = "https://search.aiserver.cloud/v1/api";
        
        JSONObject payload = new JSONObject();
        payload.put("engine", "china");
        payload.put("query", "量子计算");
        payload.put("max_results", 15);
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer Your-API-KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload.toString()))
            .build();
        
        HttpResponse<String> response = client.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        System.out.println(response.body());
    }
}

示例 3：使用时间过滤

搜索最近一周内的内容。

cURL

curl --location 'https://search.aiserver.cloud/v1/api' \
  --header 'Authorization: Bearer Your-API-KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "engine": "china",
    "query": "科技新闻",
    "time_filter": "week"
  }'

Python

import requests

response = requests.post(
    'https://search.aiserver.cloud/v1/api',
    headers={
        'Authorization': 'Bearer Your-API-KEY',
        'Content-Type': 'application/json'
    },
    json={
        'engine': 'china',
        'query': '科技新闻',
        'time_filter': 'week'
    }
)

print(response.json())

JavaScript

fetch('https://search.aiserver.cloud/v1/api', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer Your-API-KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    engine: 'china',
    query: '科技新闻',
    time_filter: 'week'
  })
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

TypeScript

async function search() {
  const response = await fetch('https://search.aiserver.cloud/v1/api', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer Your-API-KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      engine: 'china',
      query: '科技新闻',
      time_filter: 'week'
    })
  });
  
  return await response.json();
}

search().then(data => console.log(data));

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import org.json.JSONObject;

public class WebSearchExample {
    public static void main(String[] args) throws Exception {
        String url = "https://search.aiserver.cloud/v1/api";
        
        JSONObject payload = new JSONObject();
        payload.put("engine", "china");
        payload.put("query", "科技新闻");
        payload.put("time_filter", "week");
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer Your-API-KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload.toString()))
            .build();
        
        HttpResponse<String> response = client.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        System.out.println(response.body());
    }
}

PHP

<?php

$url = 'https://search.aiserver.cloud/v1/api';
$headers = [
    'Authorization: Bearer Your-API-KEY',
    'Content-Type: application/json'
];

$data = [
    'engine' => 'china',
    'query' => '科技新闻',
    'time_filter' => 'week'
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);

?>

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "https://search.aiserver.cloud/v1/api"
    
    payload := map[string]interface{}{
        "engine": "china",
        "query": "科技新闻",
        "time_filter": "week",
    }
    
    jsonData, _ := json.Marshal(payload)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer Your-API-KEY")
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Ruby

require 'net/http'
require 'json'
require 'uri'

url = URI('https://search.aiserver.cloud/v1/api')
headers = {
  'Authorization' => 'Bearer Your-API-KEY',
  'Content-Type' => 'application/json'
}

data = {
  engine: 'china',
  query: '科技新闻',
  time_filter: 'week'
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url, headers)
request.body = data.to_json

response = http.request(request)
result = JSON.parse(response.body)

puts JSON.pretty_generate(result)

示例 4：域名包含过滤（仅搜索指定网站）

仅在指定的域名中搜索内容。

cURL

curl --location 'https://search.aiserver.cloud/v1/api' \
  --header 'Authorization: Bearer Your-API-KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "engine": "china",
    "query": "人工智能",
    "include_domains": ["36kr.com", "thepaper.cn", "toutiao.com"]
  }'

Python

import requests

response = requests.post(
    'https://search.aiserver.cloud/v1/api',
    headers={
        'Authorization': 'Bearer Your-API-KEY',
        'Content-Type': 'application/json'
    },
    json={
        'engine': 'china',
        'query': '人工智能',
        'include_domains': ['36kr.com', 'thepaper.cn', 'toutiao.com']
    }
)

print(response.json())

JavaScript

fetch('https://search.aiserver.cloud/v1/api', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer Your-API-KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    engine: 'china',
    query: '人工智能',
    include_domains: ['36kr.com', 'thepaper.cn', 'toutiao.com']
  })
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

TypeScript

async function search() {
  const response = await fetch('https://search.aiserver.cloud/v1/api', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer Your-API-KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      engine: 'china',
      query: '人工智能',
      include_domains: ['36kr.com', 'thepaper.cn', 'toutiao.com']
    })
  });
  
  return await response.json();
}

search().then(data => console.log(data));

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import org.json.JSONObject;
import org.json.JSONArray;

public class WebSearchExample {
    public static void main(String[] args) throws Exception {
        String url = "https://search.aiserver.cloud/v1/api";
        
        JSONObject payload = new JSONObject();
        payload.put("engine", "china");
        payload.put("query", "人工智能");
        
        JSONArray domains = new JSONArray();
        domains.put("36kr.com");
        domains.put("thepaper.cn");
        domains.put("toutiao.com");
        payload.put("include_domains", domains);
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer Your-API-KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload.toString()))
            .build();
        
        HttpResponse<String> response = client.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        System.out.println(response.body());
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "https://search.aiserver.cloud/v1/api"
    
    payload := map[string]interface{}{
        "engine": "china",
        "query": "人工智能",
        "include_domains": []string{"36kr.com", "thepaper.cn", "toutiao.com"},
    }
    
    jsonData, _ := json.Marshal(payload)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer Your-API-KEY")
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Ruby

require 'net/http'
require 'json'
require 'uri'

url = URI('https://search.aiserver.cloud/v1/api')
headers = {
  'Authorization' => 'Bearer Your-API-KEY',
  'Content-Type' => 'application/json'
}

data = {
  engine: 'china',
  query: '人工智能',
  include_domains: ['36kr.com', 'thepaper.cn', 'toutiao.com']
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url, headers)
request.body = data.to_json

response = http.request(request)
result = JSON.parse(response.body)

puts JSON.pretty_generate(result)

PHP

<?php

$url = 'https://search.aiserver.cloud/v1/api';
$headers = [
    'Authorization: Bearer Your-API-KEY',
    'Content-Type: application/json'
];

$data = [
    'engine' => 'china',
    'query' => '人工智能',
    'include_domains' => ['36kr.com', 'thepaper.cn', 'toutiao.com']
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);

?>

示例 5：域名排除过滤

排除特定域名的搜索结果。

cURL

curl --location 'https://search.aiserver.cloud/v1/api' \
  --header 'Authorization: Bearer Your-API-KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "query": "机器学习教程",
    "exclude_domains": ["csdn.net", "jianshu.com"]
  }'

Python

import requests

response = requests.post(
    'https://search.aiserver.cloud/v1/api',
    headers={
        'Authorization': 'Bearer Your-API-KEY',
        'Content-Type': 'application/json'
    },
    json={
        'query': '机器学习教程',
        'exclude_domains': ['csdn.net', 'jianshu.com']
    }
)

print(response.json())

JavaScript

fetch('https://search.aiserver.cloud/v1/api', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer Your-API-KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    query: '机器学习教程',
    exclude_domains: ['csdn.net', 'jianshu.com']
  })
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

TypeScript

interface SearchRequest {
  engine?: 'china' | 'global';
  query: string;
  max_results?: number;
  time_filter?: 'day' | 'week' | 'month' | 'year';
  include_domains?: string[];
  exclude_domains?: string[];
}

async function search(params: SearchRequest) {
  const response = await fetch('https://search.aiserver.cloud/v1/api', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer Your-API-KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(params)
  });
  
  return await response.json();
}

// 使用示例
search({
  query: '机器学习教程',
  exclude_domains: ['csdn.net', 'jianshu.com']
}).then(data => console.log(data));

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import org.json.JSONObject;
import org.json.JSONArray;

public class WebSearchExample {
    public static void main(String[] args) throws Exception {
        String url = "https://search.aiserver.cloud/v1/api";
        
        JSONObject payload = new JSONObject();
        payload.put("query", "机器学习教程");
        
        JSONArray excludeDomains = new JSONArray();
        excludeDomains.put("csdn.net");
        excludeDomains.put("jianshu.com");
        payload.put("exclude_domains", excludeDomains);
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer Your-API-KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload.toString()))
            .build();
        
        HttpResponse<String> response = client.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        System.out.println(response.body());
    }
}

PHP

<?php

$url = 'https://search.aiserver.cloud/v1/api';
$headers = [
    'Authorization: Bearer Your-API-KEY',
    'Content-Type: application/json'
];

$data = [
    'query' => '机器学习教程',
    'exclude_domains' => ['csdn.net', 'jianshu.com']
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);

?>

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "https://search.aiserver.cloud/v1/api"
    
    payload := map[string]interface{}{
        "query": "机器学习教程",
        "exclude_domains": []string{"csdn.net", "jianshu.com"},
    }
    
    jsonData, _ := json.Marshal(payload)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer Your-API-KEY")
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Ruby

require 'net/http'
require 'json'
require 'uri'

url = URI('https://search.aiserver.cloud/v1/api')
headers = {
  'Authorization' => 'Bearer Your-API-KEY',
  'Content-Type' => 'application/json'
}

data = {
  query: '机器学习教程',
  exclude_domains: ['csdn.net', 'jianshu.com']
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url, headers)
request.body = data.to_json

response = http.request(request)
result = JSON.parse(response.body)

puts JSON.pretty_generate(result)

示例 6：组合多个参数

同时使用引擎、结果数量、时间过滤和域名过滤。

cURL

curl --location 'https://search.aiserver.cloud/v1/api' \
  --header 'Authorization: Bearer Your-API-KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "engine": "global",
    "query": "climate change research",
    "max_results": 10,
    "time_filter": "year",
    "include_domains": ["nature.com", "science.org", "arxiv.org"],
    "exclude_domains": ["wikipedia.org"]
  }'

Python

import requests

response = requests.post(
    'https://search.aiserver.cloud/v1/api',
    headers={
        'Authorization': 'Bearer Your-API-KEY',
        'Content-Type': 'application/json'
    },
    json={
        'engine': 'global',
        'query': 'climate change research',
        'max_results': 10,
        'time_filter': 'year',
        'include_domains': ['nature.com', 'science.org', 'arxiv.org'],
        'exclude_domains': ['wikipedia.org']
    }
)

print(response.json())

JavaScript

fetch('https://search.aiserver.cloud/v1/api', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer Your-API-KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    engine: 'global',
    query: 'climate change research',
    max_results: 10,
    time_filter: 'year',
    include_domains: ['nature.com', 'science.org', 'arxiv.org'],
    exclude_domains: ['wikipedia.org']
  })
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

TypeScript

async function search() {
  const response = await fetch('https://search.aiserver.cloud/v1/api', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer Your-API-KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      engine: 'global',
      query: 'climate change research',
      max_results: 10,
      time_filter: 'year',
      include_domains: ['nature.com', 'science.org', 'arxiv.org'],
      exclude_domains: ['wikipedia.org']
    })
  });
  
  return await response.json();
}

search().then(data => console.log(data));

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import org.json.JSONObject;
import org.json.JSONArray;

public class WebSearchExample {
    public static void main(String[] args) throws Exception {
        String url = "https://search.aiserver.cloud/v1/api";
        
        JSONObject payload = new JSONObject();
        payload.put("engine", "global");
        payload.put("query", "climate change research");
        payload.put("max_results", 10);
        payload.put("time_filter", "year");
        
        JSONArray includeDomains = new JSONArray();
        includeDomains.put("nature.com");
        includeDomains.put("science.org");
        includeDomains.put("arxiv.org");
        payload.put("include_domains", includeDomains);
        
        JSONArray excludeDomains = new JSONArray();
        excludeDomains.put("wikipedia.org");
        payload.put("exclude_domains", excludeDomains);
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer Your-API-KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload.toString()))
            .build();
        
        HttpResponse<String> response = client.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        System.out.println(response.body());
    }
}

PHP

<?php

$url = 'https://search.aiserver.cloud/v1/api';
$headers = [
    'Authorization: Bearer Your-API-KEY',
    'Content-Type: application/json'
];

$data = [
    'engine' => 'global',
    'query' => 'climate change research',
    'max_results' => 10,
    'time_filter' => 'year',
    'include_domains' => ['nature.com', 'science.org', 'arxiv.org'],
    'exclude_domains' => ['wikipedia.org']
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);

?>

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "https://search.aiserver.cloud/v1/api"
    
    payload := map[string]interface{}{
        "engine": "global",
        "query": "climate change research",
        "max_results": 10,
        "time_filter": "year",
        "include_domains": []string{"nature.com", "science.org", "arxiv.org"},
        "exclude_domains": []string{"wikipedia.org"},
    }
    
    jsonData, _ := json.Marshal(payload)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer Your-API-KEY")
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Ruby

require 'net/http'
require 'json'
require 'uri'

url = URI('https://search.aiserver.cloud/v1/api')
headers = {
  'Authorization' => 'Bearer Your-API-KEY',
  'Content-Type' => 'application/json'
}

data = {
  engine: 'global',
  query: 'climate change research',
  max_results: 10,
  time_filter: 'year',
  include_domains: ['nature.com', 'science.org', 'arxiv.org'],
  exclude_domains: ['wikipedia.org']
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url, headers)
request.body = data.to_json

response = http.request(request)
result = JSON.parse(response.body)

puts JSON.pretty_generate(result)

示例 7：全球引擎搜索

使用全球引擎进行搜索。

cURL

curl --location 'https://search.aiserver.cloud/v1/api' \
  --header 'Authorization: Bearer Your-API-KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "engine": "global",
    "query": "latest AI developments",
    "max_results": 8
  }'

Python

import requests

response = requests.post(
    'https://search.aiserver.cloud/v1/api',
    headers={
        'Authorization': 'Bearer Your-API-KEY',
        'Content-Type': 'application/json'
    },
    json={
        'engine': 'global',
        'query': 'latest AI developments',
        'max_results': 8
    }
)

print(response.json())

JavaScript

fetch('https://search.aiserver.cloud/v1/api', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer Your-API-KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    engine: 'global',
    query: 'latest AI developments',
    max_results: 8
  })
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

TypeScript

async function search() {
  const response = await fetch('https://search.aiserver.cloud/v1/api', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer Your-API-KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      engine: 'global',
      query: 'latest AI developments',
      max_results: 8
    })
  });
  
  return await response.json();
}

search().then(data => console.log(data));

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import org.json.JSONObject;

public class WebSearchExample {
    public static void main(String[] args) throws Exception {
        String url = "https://search.aiserver.cloud/v1/api";
        
        JSONObject payload = new JSONObject();
        payload.put("engine", "global");
        payload.put("query", "latest AI developments");
        payload.put("max_results", 8);
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer Your-API-KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload.toString()))
            .build();
        
        HttpResponse<String> response = client.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        System.out.println(response.body());
    }
}

PHP

<?php

$url = 'https://search.aiserver.cloud/v1/api';
$headers = [
    'Authorization: Bearer Your-API-KEY',
    'Content-Type: application/json'
];

$data = [
    'engine' => 'global',
    'query' => 'latest AI developments',
    'max_results' => 8
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);

?>

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "https://search.aiserver.cloud/v1/api"
    
    payload := map[string]interface{}{
        "engine": "global",
        "query": "latest AI developments",
        "max_results": 8,
    }
    
    jsonData, _ := json.Marshal(payload)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer Your-API-KEY")
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Ruby

require 'net/http'
require 'json'
require 'uri'

url = URI('https://search.aiserver.cloud/v1/api')
headers = {
  'Authorization' => 'Bearer Your-API-KEY',
  'Content-Type' => 'application/json'
}

data = {
  engine: 'global',
  query: 'latest AI developments',
  max_results: 8
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url, headers)
request.body = data.to_json

response = http.request(request)
result = JSON.parse(response.body)

puts JSON.pretty_generate(result)

示例 8：最近 24 小时内的内容

搜索最近一天内发布或更新的内容。

cURL

curl --location 'https://search.aiserver.cloud/v1/api' \
  --header 'Authorization: Bearer Your-API-KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "engine": "china",
    "query": "今日热点",
    "max_results": 20,
    "time_filter": "day"
  }'

Python

import requests

response = requests.post(
    'https://search.aiserver.cloud/v1/api',
    headers={
        'Authorization': 'Bearer Your-API-KEY',
        'Content-Type': 'application/json'
    },
    json={
        'engine': 'china',
        'query': '今日热点',
        'max_results': 20,
        'time_filter': 'day'
    }
)

print(response.json())

JavaScript

fetch('https://search.aiserver.cloud/v1/api', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer Your-API-KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    engine: 'china',
    query: '今日热点',
    max_results: 20,
    time_filter: 'day'
  })
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

TypeScript

async function search() {
  const response = await fetch('https://search.aiserver.cloud/v1/api', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer Your-API-KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      engine: 'china',
      query: '今日热点',
      max_results: 20,
      time_filter: 'day'
    })
  });
  
  return await response.json();
}

search().then(data => console.log(data));

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import org.json.JSONObject;

public class WebSearchExample {
    public static void main(String[] args) throws Exception {
        String url = "https://search.aiserver.cloud/v1/api";
        
        JSONObject payload = new JSONObject();
        payload.put("engine", "china");
        payload.put("query", "今日热点");
        payload.put("max_results", 20);
        payload.put("time_filter", "day");
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer Your-API-KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload.toString()))
            .build();
        
        HttpResponse<String> response = client.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        System.out.println(response.body());
    }
}

PHP

<?php

$url = 'https://search.aiserver.cloud/v1/api';
$headers = [
    'Authorization: Bearer Your-API-KEY',
    'Content-Type: application/json'
];

$data = [
    'engine' => 'china',
    'query' => '今日热点',
    'max_results' => 20,
    'time_filter' => 'day'
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);

?>

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    url := "https://search.aiserver.cloud/v1/api"
    
    payload := map[string]interface{}{
        "engine": "china",
        "query": "今日热点",
        "max_results": 20,
        "time_filter": "day",
    }
    
    jsonData, _ := json.Marshal(payload)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer Your-API-KEY")
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Ruby

require 'net/http'
require 'json'
require 'uri'

url = URI('https://search.aiserver.cloud/v1/api')
headers = {
  'Authorization' => 'Bearer Your-API-KEY',
  'Content-Type' => 'application/json'
}

data = {
  engine: 'china',
  query: '今日热点',
  max_results: 20,
  time_filter: 'day'
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url, headers)
request.body = data.to_json

response = http.request(request)
result = JSON.parse(response.body)

puts JSON.pretty_generate(result)

错误码

错误码	说明
`ERR_PARAM`	参数错误（如 `query` 为空、`engine` 不合法）
`ERR_KEYS`	API Key 不存在 / 已过期 / 已停用
`ERR_PRODUCT`	对应引擎产品被停用或未开通
`ERR_BALANCE`	余额或次数不足，请先充值
`ERR_SEARCH`	搜索请求失败或网络异常
`ERR_SYSTEM`	系统异常

错误响应示例

{
  "code": "ERR_BALANCE",
  "msg": "余额不足，请先充值"
}

注意事项

项目	说明
域名验证	平台会对域名数组做格式校验与数量限制（最多 20 个）
结果数量	`max_results` 范围为 1-20
搜索词长度	建议不超过 500 字符
超时设置	建议客户端设置 30 秒超时
并发限制	请合理控制并发请求数量

链接	说明
控制台	获取 API Key、查看用量
快速开始	5 分钟完成首次调用
产品介绍	了解双引擎架构
定价	查看计费规则