Appearance
骑手「注册在本地、人却在外省」?用 IP 归属地识别众包异地虚假注册与代跑(Go 实现)
做过同城配送的朋友大概都听过这两个数字:一个是新人补贴的核销率,一个是骑手的「活跃属地分布」。前者突然冲高、后者明显发散,往往说明同一件事发生了——有人盯上了你的补贴。
众包骑手是门槛最低的运力形态:注册、实名、跑单,不用坐班。好处是运力弹性,坏处是补贴规则一旦公开,就会被当成可批量复制的生意:用异地 IP 批量注册拿新人奖、把账号交给别人代跑、或者干脆挂着抢单外挂。这些人有一个共同点:账号档案里写着「常驻某市」,可实际操作的位置长期不在那儿。
一、GPS 都有了,为什么还要看 IP 归属地
先回答这个最常被问的问题:骑手 App 里 GPS 定位是强制的,风控为什么还要 IP?
因为GPS 是客户端上报的,IP 是你服务端看到的。两者的可信度不在一个量级:
- GPS 可以伪造。虚拟定位 App、模拟器、改机工具在灰产里是标准配置,带虚拟定位的「抢单辅助」工具在圈子里从来不缺。
- IP 归属地不好随手改。想让服务端看到另一个城市的 IP,得挂代理、租异地服务器,这要花钱,还会在特征上留下痕迹——比如出口落到机房段(
ip_type可以区分家宽 / 企业 / 机房,属于 VIP 版字段)。 - 伪造 GPS 的人往往忘了 IP 这回事。这就是 IP 归属地在风控里的价值:它是一条独立的、成本更高的旁证。
同时必须说清它的上限:IP 归属地只到城市级,运营商动态分配 IP、CGNAT 共享出口、跨城通勤、节假日回乡都会让它「漂」。所以它只能用来给可疑账号排序、决定谁进人工复核,不能单独作为判罚依据。任何把它当判决书用的方案,最后都会误伤一批正常骑手。
二、要抓的三种形态
| 形态 | 特征 | 主要看什么 |
|---|---|---|
| A 异地批量注册骗补贴 | 一批账号注册 IP 集中在少数几个 IP 段,注册属地与档案常驻城市不符,且这些账号的登录属地分散在多个城市 | 注册 IP 段聚集度 + 注册城市偏离 |
| B 账号代跑 / 共享 | 账号登录属地长期稳定在另一座城市,与档案城市一致率很低 | 属地城市数 + 与常驻城市的一致率 |
| C 抢单外挂 | 抢单请求频率异常,出口是机房 IP,属地与所抢订单的城市长期不符 | 频率 + IP 类型 + 属地一致性 |
三种形态的权重不同,但都依赖同一件事:把「IP → 城市」这一步做扎实,并且缓存好。骑手端的登录、接单、心跳都是高频事件,一个几千人的平台一天产生的 IP 就几十万个,不做缓存直接查接口,额度会在几小时内耗尽。
三、Go 实现:属地标签 + 一致率打分
下面这段代码做两件事:给一批 IP 打属地标签(带进程内缓存和串行限速),再按「属地分散度」和「与常驻城市的一致率」输出复核清单。它适合放在离线任务里跑,也可以把 lookup 抽出来做成 HTTP 中间件,在登录/接单请求上打标。
go
// ridergeo.go —— 众包骑手属地风控:给登录/接单 IP 打属地标签,算「常驻城市一致率」
// 用法: go run ridergeo.go riders.json
// go run ridergeo.go -self 223.5.5.5
package main
import (
"encoding/json"
"flag"
"fmt"
"io"
"net/http"
"os"
"sort"
"strings"
"sync"
"time"
)
const api = "https://ip9.com.cn/get"
// 免费版 60 次/分钟/IP,串行调用留一点余量
const paceInterval = 1100 * time.Millisecond
type apiResp struct {
Ret int `json:"ret"`
Data struct {
IP string `json:"ip"`
Prov string `json:"prov"`
City string `json:"city"`
ISP string `json:"isp"`
Area string `json:"area"` // 区县:VIP 版字段,免费版为空
} `json:"data"`
}
// Geo 是我们真正关心的三个字段
type Geo struct {
Prov, City, ISP string
}
type Rider struct {
ID string `json:"id"`
HomeCity string `json:"home_city"` // 骑手档案里自己填的常驻城市
RegIP string `json:"reg_ip"`
LoginIPs []string `json:"login_ips"` // 近 30 天登录/接单时的 IP
}
// geoCache 进程内缓存:同一个 IP 一天内只查一次
type geoCache struct {
mu sync.Mutex
m map[string]Geo
}
func (c *geoCache) get(ip string) (Geo, bool) {
c.mu.Lock()
defer c.mu.Unlock()
g, ok := c.m[ip]
return g, ok
}
func (c *geoCache) put(ip string, g Geo) {
c.mu.Lock()
defer c.mu.Unlock()
c.m[ip] = g
}
var privatePrefix = []string{"10.", "172.16.", "172.17.", "172.18.", "192.168.", "127.", "169.254."}
func isPrivate(ip string) bool {
for _, p := range privatePrefix {
if strings.HasPrefix(ip, p) {
return true
}
}
return ip == "" || strings.Contains(ip, ":") // 内网和 IPv6 字面量这里先放过,生产环境按业务处理
}
// lookup 查一个 IP 的属地;查询失败返回 ok=false,调用方自己决定怎么兜底
func lookup(client *http.Client, c *geoCache, ticker *time.Ticker, ip string) (Geo, bool) {
if isPrivate(ip) {
return Geo{}, false
}
if g, ok := c.get(ip); ok {
return g, g.Prov != ""
}
<-ticker.C // 限速:串行拉长间隔,别把免费额度打满
req, _ := http.NewRequest(http.MethodGet, api+"?ip="+ip, nil)
req.Header.Set("Accept", "application/json")
resp, err := client.Do(req)
if err != nil {
fmt.Fprintf(os.Stderr, "[warn] %s 请求失败: %v\n", ip, err)
return Geo{}, false
}
defer resp.Body.Close()
body, err := io.ReadAll(io.LimitReader(resp.Body, 8192))
if err != nil {
fmt.Fprintf(os.Stderr, "[warn] %s 读取失败: %v\n", ip, err)
return Geo{}, false
}
var r apiResp
if err := json.Unmarshal(body, &r); err != nil {
fmt.Fprintf(os.Stderr, "[warn] %s 返回不是 JSON: %s\n", ip, string(body))
return Geo{}, false
}
switch r.Ret {
case 200:
g := Geo{Prov: r.Data.Prov, City: r.Data.City, ISP: r.Data.ISP}
c.put(ip, g)
return g, true
case 400:
c.put(ip, Geo{}) // IP 不合法是确定结果,缓存起来别反复问
return Geo{}, false
case 429:
fmt.Fprintln(os.Stderr, "[warn] 触发限速(ret=429),暂停 10 秒")
time.Sleep(10 * time.Second)
return Geo{}, false
default:
fmt.Fprintf(os.Stderr, "[warn] %s 接口异常 ret=%d\n", ip, r.Ret)
return Geo{}, false
}
}
type verdict struct {
Rider string
Home string
Cities string
Distinct int
Match float64
Level string
Note string
}
type GeoLookup func(string) (Geo, bool)
// judge 只看两件事:属地分布有多散、跟常驻城市对得上多少
func judge(r Rider, g GeoLookup) verdict {
reg, _ := g(r.RegIP)
seen := map[string]bool{}
order := []string{}
for _, ip := range append([]string{r.RegIP}, r.LoginIPs...) {
geo, ok := g(ip)
if !ok {
continue
}
k := geo.City
if k == "" {
k = geo.Prov
}
if k == "" || seen[k] {
continue
}
seen[k] = true
order = append(order, k)
}
total, matched := 0, 0
for _, ip := range append([]string{r.RegIP}, r.LoginIPs...) {
geo, ok := g(ip)
if !ok || geo.City == "" {
continue
}
total++
if geo.City == r.HomeCity {
matched++
}
}
rate := 0.0
if total > 0 {
rate = float64(matched) / float64(total)
}
v := verdict{
Rider: r.ID, Home: r.HomeCity,
Cities: strings.Join(order, ","), Distinct: len(seen),
Match: rate, Level: "正常",
}
switch {
case reg.City != "" && reg.City != r.HomeCity && len(seen) >= 3:
v.Level, v.Note = "人工复核", "注册地非常驻城市且属地跨 "+fmt.Sprint(len(seen))+" 城"
case len(seen) >= 2 && rate <= 0.3:
v.Level, v.Note = "人工复核", "属地分散且与常驻城市一致率过低"
case (reg.City != "" && reg.City != r.HomeCity) || len(seen) >= 2:
v.Level, v.Note = "观察", "存在异地属地,可能是跨城通勤或账号共享"
}
return v
}
func main() {
self := flag.String("self", "", "只查一个 IP 并退出")
flag.Parse()
client := &http.Client{Timeout: 3 * time.Second}
cache := &geoCache{m: map[string]Geo{}}
ticker := time.NewTicker(paceInterval)
defer ticker.Stop()
if *self != "" {
g, ok := lookup(client, cache, ticker, *self)
if !ok {
fmt.Println("[失败] 查询不到结果")
os.Exit(1)
}
fmt.Printf("%s %s/%s 运营商=%s\n", *self, g.Prov, g.City, g.ISP)
return
}
path := flag.Arg(0)
if path == "" {
fmt.Fprintln(os.Stderr, "用法: go run ridergeo.go riders.json")
os.Exit(2)
}
raw, err := os.ReadFile(path)
if err != nil {
fmt.Fprintln(os.Stderr, "读取失败:", err)
os.Exit(1)
}
var riders []Rider
if err := json.Unmarshal(raw, &riders); err != nil {
fmt.Fprintln(os.Stderr, "JSON 解析失败:", err)
os.Exit(1)
}
lookupFn := func(ip string) (Geo, bool) { return lookup(client, cache, ticker, ip) }
out := make([]verdict, 0, len(riders))
for _, r := range riders {
out = append(out, judge(r, lookupFn))
}
sort.SliceStable(out, func(i, j int) bool { return out[i].Match < out[j].Match })
fmt.Printf("%-8s %-6s %-6s %-28s %-10s %-10s %s\n", "骑手", "常驻", "属地数", "查到的城市", "一致率", "结论", "说明")
for _, v := range out {
fmt.Printf("%-8s %-6s %-6d %-28s %-10s %-10s %s\n",
v.Rider, v.Home, v.Distinct, v.Cities, fmt.Sprintf("%.0f%%", v.Match*100), v.Level, v.Note)
}
review := 0
for _, v := range out {
if v.Level == "人工复核" {
review++
}
}
fmt.Printf("\n共 %d 名骑手,需人工复核 %d 名\n", len(out), review)
}输入样例:
json
[
{"id":"R001","home_city":"杭州","reg_ip":"223.5.5.5","login_ips":["114.114.114.114","119.29.29.29","223.6.6.6"]},
{"id":"R002","home_city":"北京","reg_ip":"223.5.5.5","login_ips":["223.5.5.5","223.6.6.6"]},
{"id":"R003","home_city":"深圳","reg_ip":"1.2.4.8","login_ips":["114.114.114.114","223.5.5.5"]}
]实跑输出:
text
$ go run ridergeo.go riders.json
骑手 常驻 属地数 查到的城市 一致率 结论 说明
R002 北京 1 杭州 0% 观察 存在异地属地,可能是跨城通勤或账号共享
R003 深圳 2 南京,杭州 0% 人工复核 属地分散且与常驻城市一致率过低
R001 杭州 3 杭州,南京,广州 50% 观察 存在异地属地,可能是跨城通勤或账号共享
共 3 名骑手,需人工复核 1 名
$ go run ridergeo.go -self 223.5.5.5
223.5.5.5 浙江/杭州 运营商=AliDNS/DoH/DoT/阿里云看结果能发现两件事。R001 的属地跨了三个城市(杭州、南京、广州)、一致率只有 50%,但它注册地就是杭州,所以只落到「观察」——这正是阈值设计的意义:注册地对得上,异地就可能只是出差或换网。R003 的注册地(南京)与档案城市(深圳)不符,属地又分散,直接进复核队列。
四、落地时最容易出错的地方
先跑基线,再定阈值。 上面那几个数字(3 城、30%)是演示值,不能照抄。正确顺序是:先拿平台现有骑手近 30 天的登录 IP 跑一遍分布,看看「正常骑手」跨几个城市、一致率中位数是多少,再往外挪一点定阈值。众包骑手的实际情况比想象中散:住在昆山跑上海、住在燕郊跑北京、周末回乡的,都能自然产生跨城属地。
跨城通勤必须能申诉。 有相当比例的骑手本来就在两个城市之间来回。处置方案要分级:先站内提醒、再限制补贴核销、最后才人工复核;每一步都留申诉入口,让骑手提交居住证明或跑单轨迹。直接封号带来的是运力流失和投诉,比那点补贴贵。
CGNAT 和共享出口要豁免。 出租房、群租房、园区宽带常见同楼几户共用一个出口 IP,IPv6 普及之后这种情况少一些,但没消失。遇到「同 IP 多个骑手」先别急着判团伙,结合设备和行为看;能拿到 ip_type(VIP 版字段)时,机房 IP 的权重可以调高一档,家宽共享的调低。
别把属地当成「人在撒谎」的证据。 运营商动态分配、跨省 IP 池、边界基站漂移都会让属地对不上,这是常态而不是异常。所有规则的输出都应该是「这个人值得看一眼」,而不是「这个人有问题」。
IP 是个人信息,合规部分别省。 隐私政策和骑手协议里要写明「为保障账号与补贴安全,我们会记录登录 IP,并用于属地风控」;对外展示(比如给运营看的清单)只到省市,不带完整 IP;原始 IP 的留存期限要定清楚,画像跑完的中间缓存按天清理。
查询这一层一定要有缓存和限速。 骑手端登录 + 抢单 + 心跳都是高频事件,直接把每个请求都转发给 IP 接口,等于把配额往火里扔。上面的 geoCache 是进程内的最简版;多实例部署时换成 Redis,key 用 IP、value 存省市 + 时间戳,TTL 设一天,效果更稳。
总结
异地虚假注册和代跑这类问题,本质是「账号档案说的位置」和「实际操作的位置」对不上。GPS 是客户端上报的,能被伪造;IP 归属地是服务端观察到的,改起来成本高得多,两者交叉起来用,比单独信任何一个都稳。
查询就一个 GET:https://ip9.com.cn/get?ip=<IP>(不传参数返回当前请求方 IP,IPv4/IPv6 都支持),免费版无需注册、60 次/分钟/IP,返回国家、省市、邮编、区号、运营商、经纬度(城市中心);需要区县 area、ip_type(家宽/企业/机房)、ip_asn 时属于 VIP 版能力,具体口径见 https://www.ip9.com.cn。批量场景记得循环调用单 IP 接口,配合缓存 + 限速,别让免费额度在半小时内烧完。