Skip to content

骑手「注册在本地、人却在外省」?用 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 接口,配合缓存 + 限速,别让免费额度在半小时内烧完。