百度智能云referer api接口 支持 php go语言 python 源码 可以获取百度关键词 解决取消referer关键词Seo sem 统计问题 百度统计搜索关键词 统计数据流量

Api地址：https://cloud.baidu.com/doc/RefererAPI/s/hjwvycn07?qq-pf-to=pcqq.c2c

鉴权地址：https://cloud.baidu.com/doc/Reference/s/Njwvz1wot

账号申请：https://cloud.baidu.com/doc/Reference/s/9jwvz2egb

注意：目前次接口仅支持北京的BCC服务器调用

php代码

<?php


// 根据RFC 3986，除了：
//   1.大小写英文字符
//   2.阿拉伯数字
//   3.点'.'、波浪线'~'、减号'-'以及下划线'_'
// 以外都要编码
global $PERCENT_ENCODED_STRINGS ;
 __init();
//填充编码数组
function __init()
{
    global $PERCENT_ENCODED_STRINGS ;
    for ($i = 0; $i < 256; ++$i) {
        $PERCENT_ENCODED_STRINGS[$i] = sprintf("%%%02X", $i);
    }
    //a-z不编码
    foreach (range('a', 'z') as $ch) {
        $PERCENT_ENCODED_STRINGS[ord($ch)] = $ch;
    }
    //A-Z不编码
    foreach (range('A', 'Z') as $ch) {
        $PERCENT_ENCODED_STRINGS[ord($ch)] = $ch;
    }
    //0-9不编码
    foreach (range('0', '9') as $ch) {
        $PERCENT_ENCODED_STRINGS[ord($ch)] = $ch;
    }
    //以下4个字符不编码
    $PERCENT_ENCODED_STRINGS[ord('-')] = '-';
    $PERCENT_ENCODED_STRINGS[ord('.')] = '.';
    $PERCENT_ENCODED_STRINGS[ord('_')] = '_';
    $PERCENT_ENCODED_STRINGS[ord('~')] = '~';
}


//使用编码数组编码
function doUrlEncode($value)
{
    global $PERCENT_ENCODED_STRINGS ;

    $result = '';
    for ($i = 0; $i < strlen($value); ++$i) {
        $result .= $PERCENT_ENCODED_STRINGS[ord($value[$i])];
    }
    return $result;
}

function urlEncodeExceptSlash($path)
{
    return str_replace("%2F", "/", doUrlEncode($path));
}

//生成标准化uri
function getCanonicalURIPath($path)
{
    //空路径设置为'/'
    if (empty($path)) {
        return '/';
    } else {
        //所有的uri必须以'/'开头
        if ($path[0] == '/') {
            return urlEncodeExceptSlash($path);
        } else {
            return '/' . urlEncodeExceptSlash($path);
        }
    }
}


/**
 * 获取认证字符串
 *
 *  任务一：创建前缀字符串(authStringPrefix)
 *  任务二：创建规范请求(canonicalRequest)，确定签名头域(signedHeaders)
 *  任务三：生成派生签名密钥(signingKey)
 *  任务四：生成签名摘要(signature)，并拼接最终的认证字符串(authorization)
 *
 * @param $accessKey
 * @param $secretKey
 * @param $utcTimeStr
 * @param $url
 * @param $httpMethod
 */
function getAuth($accessKey, $secretKey, $utcTimeStr, $url, $httpMethod)
{
    $urlParseRet = parse_url($url);

    if (null === $urlParseRet) {
        throw new \Exception('url error');
    }

    $host = isset($urlParseRet['host']) ? $urlParseRet['host'] : '';
    $path = isset($urlParseRet['path']) ? $urlParseRet['path'] : '';

    $version = "1";
    $expirationSeconds = "1800";
    $signatureHeaders = "host";

    //生成authString
    $authString = sprintf("bce-auth-v%s/%s/%s/%s", $version, $accessKey, $utcTimeStr, $expirationSeconds);

    //使用sk和authString生成signKey
    $signingKey = hash_hmac('sha256', $authString, $secretKey);


    //生成标准化uri
    $canonicalURI = getCanonicalURIPath($path);

    //生成标准化QueryString
    $canonicalQueryString = '';

    //CanonicalHeaders
    $canonicalHeader = $signatureHeaders . ':' . $host;


    //组成标准请求串
    $canonicalRequest = "$httpMethod\n$canonicalURI\n" . "$canonicalQueryString\n$canonicalHeader";

    //使用signKey和标准请求串完成签名
    $signature = hash_hmac('sha256', $canonicalRequest, $signingKey);

    //组成最终签名串
    return "$authString/$signatureHeaders/$signature";

}

$accessKey = 'XXXXX';//(ak)
$secretKey = 'XXXXX';//(sk)
$eqid = "8dc269c900038be6000000055fa9eb6f";//document.referrer获取
$url = "http://referer.bj.baidubce.com/v1/eqid/{$eqid}";
$httpMethod = 'GET';

//设定时间戳，注意：如果自行指定时间戳需要为UTC时间
$timestamp = new \DateTime();
$timestamp->setTimezone(new \DateTimeZone("UTC"));
$utcTimeStr = $timestamp->format("Y-m-d\TH:i:s\Z");

//第一步：生成认证字符串
$auth = getAuth($accessKey, $secretKey, $utcTimeStr, $url, $httpMethod);


// 第二步：构造HTTP请求的header、body等信息
//注意head的格式不是key=>value
$head = array(
    "accept-encoding: gzip, deflate",//非必填
    "host: referer.bj.baidubce.com",//非必填
    "content-type: application/json",
    "authorization:{$auth}",
    "x-bce-date:{$utcTimeStr}",
    "accept: */*"//非必填
);

// 第三步：发送HTTP请求，并输出响应信息。
$curl = curl_init();
curl_setopt($curl, CURLOPT_URL, $url);
curl_setopt($curl, CURLOPT_HTTPHEADER, $head);
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($curl, CURLINFO_HEADER_OUT, 1);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($curl);
$request = curl_getinfo($curl, CURLINFO_HEADER_OUT);
$status = curl_getinfo($curl, CURLINFO_HTTP_CODE);
curl_close($curl);
print("request: {$request}\n");
print("status: {$status}\n");
print("response: {$response}\n");
exit;


?>

go语言代码

package main
 
import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/url"
	"strings"
	"time"
)
 
func getAuth(accessKey, accessSecret, utcTimeStr, urlstr, method string) (string, error) {
 
	urlParseRet, err := url.Parse(urlstr)
 
	if err != nil {
		return "", err
	}
 
	host := urlParseRet.Host
	path := urlParseRet.Path
	version := "1"
	expirationSeconds := "1800"
	signatureHeaders := "host"
 
	val := fmt.Sprintf("bce-auth-v%s/%s/%s/%s", version, accessKey, utcTimeStr, expirationSeconds)
 
	key := []byte(accessSecret)
	h := hmac.New(sha256.New, key)
	_, err = h.Write([]byte(val))
 
	if err != nil {
		return "", errors.New("writing key error:" + err.Error())
	}
 
	signingKey := hex.EncodeToString(h.Sum(nil))
 
	canonicalURI, err := url.PathUnescape(path)
 
	if err != nil {
		return "", errors.New("unescape path failed:" + err.Error())
	}
 
	canonicalHeaders := fmt.Sprintf("host:%s", strings.Trim(host, " "))
	canonicalRequest := fmt.Sprintf("%s\n%s\n\n%s", strings.ToUpper(method), canonicalURI, canonicalHeaders)
 
	key = []byte(signingKey)
	h = hmac.New(sha256.New, key)
	_, err = h.Write([]byte(canonicalRequest))
 
	if err != nil {
		return "", errors.New("writing signature error:" + err.Error())
	}
 
	signature := hex.EncodeToString(h.Sum(nil))
 
	authorization := fmt.Sprintf("bce-auth-v%s/%s/%s/%s/%s/%s", version, accessKey, utcTimeStr, expirationSeconds, signatureHeaders, signature)
 
	return authorization, nil
}
 
// 将时间戳（精确到秒）0转换为时间字符串
func DateTime(timestamp int64) string {
 
	var lctime = time.Unix(timestamp, 0)
 
	timelayout := "2006-01-02T15:04:05Z"
 
	lca, err := time.LoadLocation("")
 
	if err != nil {
		panic(err)
	}
	var ltime = lctime.In(lca).Format(timelayout)
 
	return ltime
}
 
func GetKeywordByEqid(eqid string) string {
	accessKey := "xxxx"
	accessSecret := "xxxx"
 
	reqUrl := "http://referer.bj.baidubce.com/v1/eqid" + "/" + eqid
	method := "GET"
 
	utcTime := time.Now().Unix()
	utcTimeStr := DateTime(utcTime)
 
	auth, _ := getAuth(accessKey, accessSecret, utcTimeStr, reqUrl, method)
 
	// 发送http请求
	client := &http.Client{}
	//提交请求
	reqest, err := http.NewRequest("GET", reqUrl, nil)
 
	//增加header选项
	reqest.Header.Add("accept-encoding", "gzip, deflate")
	reqest.Header.Add("host", "referer.bj.baidubce.com")
	reqest.Header.Add("content-type", "application/json")
	reqest.Header.Add("x-bce-date", utcTimeStr)
	reqest.Header.Add("authorization", auth)
	reqest.Header.Add("accept", "*/*")
 
	if err != nil {
		panic(err)
	}
 
	begin := time.Now()
	//处理返回结果
	response, err := client.Do(reqest)
 
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()
 
	body, err := ioutil.ReadAll(response.Body)
	if err != nil {
		panic(err)
	}
 
	result := string(body)
	fmt.Println(result)
 
	resultDecode, err := url.QueryUnescape(result)
 
	if err != nil {
		panic(err)
	}
 
	end := time.Now()
	td := end.Sub(begin)
	fmt.Println("timeUsed:\t", td)
 
	return resultDecode
}
 
func main() {
 
	result := GetKeywordByEqid("d6ebbb990001e54a000000065b7989ad")
 
	resultMap := make(map[string]string)
	err := json.Unmarshal([]byte(result), &resultMap)
 
	if err != nil {
		panic(err)
	}
 
	keyword := ""
 
	if _, ok := resultMap["wd"]; ok {
		keyword = resultMap["wd"]
	}
 
	fmt.Println(keyword)
}

python代码

#!/usr/bin/python
#encoding=utf8

import os
import sys
import urllib
import urllib2
import json
import hashlib
import hmac
import time
import datetime
from urllib import quote
from urlparse import urlparse

def gen_auth(access_key, secret_key, utc_time_str, url, method):
    url_parse_ret = urlparse(url)
    host = url_parse_ret.hostname
    path = url_parse_ret.path
    version = "1"
    expiration_seconds = "1800"
    signature_headers = "host"
    
    # 1 Generate SigningKey
    val = "bce-auth-v%s/%s/%s/%s" % (version, access_key, utc_time_str, expiration_seconds)
    signing_key = hmac.new(secret_key, val, hashlib.sha256).hexdigest().encode('utf-8')
    
    # 2 Generate CanonicalRequest
    # 2.1 Genrate CanonicalURI
    canonical_uri = quote(path)
    # 2.2 Generate CanonicalURI: not used here
    # 2.3 Generate CanonicalHeaders: only include host here
    canonical_headers = "host:%s" % quote(host).strip()
    # 2.4 Generate CanonicalRequest
    canonical_request = "%s\n%s\n\n%s" % (method.upper(), canonical_uri, canonical_headers)
    
    # 3 Generate Final Signature 
    signature = hmac.new(signing_key, canonical_request, hashlib.sha256).hexdigest()
    authorization = "bce-auth-v%s/%s/%s/%s/%s/%s" % (version, access_key, utc_time_str, expiration_seconds, signature_headers, signature)
    print authorization
    return authorization

if __name__ == "__main__":
    access_key = "ACCESS_KEY"
    secret_key = "SECRET_KEY"
    eqid="EQID"
    url = "http://referer.bj.baidubce.com/v1/eqid"+"/"+eqid
    method = "GET"
    utc_time = datetime.datetime.utcnow()
    utc_time_str = utc_time.strftime("%Y-%m-%dT%H:%M:%SZ")
    auth = gen_auth(access_key, secret_key, utc_time_str, url, method)
    
    header = {
        'accept-encoding':'gzip, deflate',
        'host':'referer.bj.baidubce.com',
        'content-type':'application/json',
        'x-bce-date': utc_time_str,
        'authorization': auth,
        'accept':'*/*'
    }
    
    print time.time()
    request = urllib2.Request(url, None, header)
    response = None
    try :
        response = urllib2.urlopen(request)
        print time.time()
        post_res_str = response.read()
        print post_res_str
    except urllib2.URLError, e:
        print "URLError"
        print e.code, e.reason
        print e.read()
    except urllib2.HTTPError, e:
        print "HTTPError"
        print e.code, e.reason
        print e.read()