How a Unified AI Gateway Cut Our Content Moderation Maintenance Costs by 93%

Our five-person team builds a UGC community product. At the end of last year, we launched the user publishing feature, and with it came an unavoidable compliance issue: all user-generated content must go through moderation.

The Business Pain Point: One Piece of Content, Three Hurdles

Initially, we evaluated content safety APIs on the market and quickly discovered a problem: a single vendor simply isn't enough.

• Vendor A for text moderation had a high false-positive rate, and users complained that "normal posts got swallowed";
• Vendor B for image moderation was cheap, but its recall rate for new variants of violating content was unstable;
• Occasional moderation errors required a second vendor for confirmation as a fallback.

So architecturally, we ended up with "multi-vendor routing": high-sensitivity content goes through the accuracy-first channel, everyday content goes through the cost-first channel, and during peak traffic we also need degradation and fallback.

Integrating directly with each vendor's native SDK would mean:

1. Three authentication methods, three request structures, three error code systems;
2. Whenever any vendor makes changes, we have to update our code and re-test;
3. Adding a new vendor takes an average of 2-3 days of integration work.

Our team has no dedicated ops staff—only three people write code. We couldn't afford this path.

Architecture Design: The Gateway Layer Handles Convergence, the Business Layer Only "Publishes Content"

The final architecture is simple:

用户发布请求
    │
    ▼
业务服务（内容进入前先过审核）
    │
    ▼
统一AI网关 ──► 审核路由策略
    │           ├─ 高风险场景 → A厂商（准确率优先）
    │           ├─ 普通文本   → B厂商（成本优先）
    │           ├─ 图片内容   → C厂商
    │           └─ 主通道超时 → 降级通道
    │
    ▼
审核结果统一结构化返回 → 业务侧放行/拦截/人工复核队列

The core idea: business code only knows one request format and one response format—all vendor differences are absorbed by the gateway layer.

Key Implementation Steps and Code

Implementation took three steps, done in a single afternoon (compared to the previous estimate of "2-3 days per vendor"):

Step 1: Configure channels for the three moderation vendors in the gateway console, filling in their respective API keys;

Step 2: Write a unified moderation call wrapper on the business side:

async def moderate_content(text: str, scene: str = "normal") -> ModerationResult:
    """统一审核入口，业务侧完全不感知底层供应商"""
    resp = await gateway.post(
        model="text-moderation",
        messages=[{"role": "user", "content": text}],
        extra={
            "route": "high_risk" if scene == "report" else "cost_first",
            "fallback": True,   # 主通道失败自动切备用
        },
        timeout=2.0,
    )
    # 所有供应商的返回都已被网关归一化为同一结构
    return ModerationResult(
        label=resp.label,          # pass / review / block
        confidence=resp.score,
        vendor=resp.vendor,        # 记录实际命中的供应商，便于对账
    )

Step 3: Branch based on the unified label field in the response—pass goes straight into the database, review goes into the manual review queue, and block gets rejected with a notice to the user.

The Efficiency Math: Exactly How Much We Saved

Two months after launch, I did a careful calculation:

Altogether, we save about 47 minutes of maintenance work per day, and the initial development cycle was compressed by 93%. For a three-person dev team, that's roughly half a headcount appearing out of thin air—and invested in product features rather than "glue code."

Another hidden benefit: the gateway console comes with built-in usage and cost reports. How much each of the three vendors costs, the hit rate for each channel—all at a glance. We used to dig through three vendors' consoles for reconciliation; now it takes 30 seconds.

Why a Unified AI Gateway Reduces Maintenance Costs

At its core, the root cause of high maintenance costs is the fan-out problem of N heterogeneous APIs × 1 codebase. A unified gateway converges this into 1 standard API + N configurations:

1. Protocol normalization: Requests, responses, and error codes are standardized at the gateway layer, decoupling business code from vendors—vendor API changes no longer trigger our releases;
2. Near-zero switching cost: When a vendor raises prices or quality drops, you can switch or do a gradual rollout by simply changing routing configuration, without rewriting code—this is especially critical in moderation scenarios where multiple vendors serve as fallbacks for each other;
3. Reuse of common capabilities: Timeout retries, degradation, rate limiting, usage tracking—things you'd have to implement yourself for every direct integration—are implemented once in the gateway and shared across all channels;
4. Centralized key management: Moderation API keys are no longer scattered across service environment variables, making security audits easier too.

Conclusion

Infrastructure like content moderation—"mandatory, but generates no business value"—is precisely what independent developers and small teams should outsource. Leave vendor differences to the gateway, and save your time for the product itself—this math pays off no matter how you calculate it.

If your project is also integrating multiple AI capabilities, you can start with a free tier and try a unified AI gateway: https://api.thistoken.ai/register

---

Ready to try it yourself? Sign up at https://api.thistoken.ai/register to get your API key and start building.