How to Use Agent47 for AI Agent Job Aggregation: A Complete MCP Guide

Agent47 is a unified MCP server that aggregates job listings from nine platforms, enabling AI agents to search remote work across x402-payable services, RentAHuman, and Virtuals through standardized function calls without API keys.

Agent47 provides a Model Context Protocol (MCP) interface for discovering employment opportunities across multiple specialized platforms. According to the punkpeye/awesome-mcp-servers repository, this TypeScript-based aggregator appears in the Aggregators section of the README, making it discoverable to any MCP-compatible client [1†L150-L151]. By following MCP standards, Agent47 allows AI agents to invoke job search tools as ordinary functions from Claude Desktop, Cursor, Cline, or custom scripts.

What Is Agent47 and How Does It Work?

Agent47 functions as a unified job aggregator that exposes employment platform data through a standardized MCP interface. Rather than maintaining separate integrations for each job board, AI agents interact with a single endpoint that normalizes queries across more than nine underlying services.

The server implements the Model Context Protocol specification, meaning it exposes tools via JSON-RPC endpoints that any MCP client can consume. When listed in the awesome-mcp-servers registry, Agent47 becomes discoverable through global MCP directories like glama.ai/mcp/servers, allowing autonomous agents to locate and invoke its capabilities without hardcoded configuration.

Architecture of the Agent47 MCP Server

The MCP Server Layer

The core implementation runs as a cloud-hosted TypeScript service that translates MCP protocol requests into platform-specific API calls. Located in the external repository espadaw/Agent47, the server exposes standardized tools that wrap underlying job platforms including x402-payable services, RentAHuman, and Virtuals.

Payment and Billing

Unlike traditional APIs requiring authentication tokens, Agent47 uses the x402 micropayment protocol to charge per-call fees. The system automatically handles payments in USDC on Base, eliminating the need for API keys while ensuring fair compensation for query processing. The MCP gateway manages settlement transparently during each function invocation.

Discovery Mechanism

Agent47's visibility depends on its entry in punkpeye/awesome-mcp-servers. The repository's README.md file under the Aggregators section provides the canonical reference that makes the server discoverable by agents scanning the global MCP registry [1†L150-L151].

Setting Up Agent47 for Job Aggregation

Prerequisites

• An MCP-compatible client (Claude Desktop, Cursor, Cline, or custom Node.js script)
• USDC on Base for x402 payments (handled automatically by the gateway)
• No API keys required

Discovery and Endpoint Retrieval

First, locate the server's endpoint through the MCP registry:

npx awesome-mcp search Agent47

This command returns the MCP endpoint URL, typically https://agent47.mcp.glama.ai.

Schema Inspection

Before calling tools, inspect the available functions to understand the parameter structure:

curl https://agent47.mcp.glama.ai/mcp/tools/list

The response lists available tools including search_jobs along with their input schemas.

Searching Jobs with Agent47

Using cURL to Call search_jobs

Execute a job search by posting to the MCP tools endpoint with your query parameters:

curl -X POST https://agent47.mcp.glama.ai/mcp/tools/call \
     -H "Content-Type: application/json" \
     -d '{
           "tool": "search_jobs",
           "params": {
             "keywords": "machine learning",
             "location": "remote",
             "min_salary": 120000
           }
         }'

The gateway automatically processes the x402 payment header and returns a normalized JSON array containing title, company, location, salary, and link fields from across all aggregated platforms.

Node.js Integration

For programmatic access, use the MCP client library to establish a persistent connection:

import { MCPClient } from '@glama/mcp-client';

// Initialize the client with Agent47's endpoint
const client = new MCPClient('https://agent47.mcp.glama.ai');

// Inspect available tools
const tools = await client.listTools();
console.log('Available tools:', tools);

// Search for remote ML jobs
const jobs = await client.callTool('search_jobs', {
  keywords: 'machine learning',
  location: 'remote',
  min_salary: 120000,
});

console.log('Jobs found:', jobs);

The MCPClient class handles the x402 payment flow automatically, allowing you to focus on query logic rather than transaction management.

Command Line Usage with npx

For quick searches without writing code, use the packaged CLI:

# List available tools

npx -y @agent47/mcp list

# Search for senior data scientist roles in Berlin

npx -y @agent47/mcp call search_jobs \
    --keywords "data scientist" \
    --location "Berlin" \
    --min_salary 150000

Both the Node.js SDK and npx commands trigger the x402 micropayment protocol transparently, deducting USDC from your wallet only when calls execute successfully.

Understanding the x402 Payment Flow

The x402 protocol replaces traditional API authentication with cryptographic payment proofs. When your client calls Agent47, the MCP gateway:

1. Intercepts the request and calculates the per-call cost
2. Requests a payment proof in USDC on Base
3. Validates the transaction
4. Forwards the request to Agent47 only after payment confirmation

This architecture eliminates API key management while creating a direct economic relationship between AI agents and data providers.

Summary

• Agent47 is a unified MCP server aggregating nine job platforms into a single interface
• The server is listed under Aggregators in punkpeye/awesome-mcp-servers/README.md [1†L150-L151]
• Integration requires no API keys, relying instead on the x402 micropayment protocol (USDC on Base)
• Clients interact via standard MCP calls to https://agent47.mcp.glama.ai, using tools like search_jobs
• Implementation options include cURL, Node.js MCPClient, or npx command-line tools
• Response data is normalized across all platforms, providing consistent title, company, location, and salary fields

Frequently Asked Questions

What platforms does Agent47 aggregate?

Agent47 collects listings from more than nine specialized employment platforms, including x402-payable services, RentAHuman, and Virtuals, presenting them through a single normalized interface. The complete list of integrated platforms is maintained in the source repository at espadaw/Agent47.

Do I need API keys to use Agent47?

No. Agent47 eliminates API key requirements by implementing the x402 micropayment protocol. Instead of authentication tokens, you pay per-call fees in USDC on Base, which the MCP gateway handles automatically during request processing.

How does the x402 payment protocol work?

The x402 protocol embeds payment validation directly into HTTP requests. When calling Agent47, your client includes a cryptographic proof of payment (USDC on Base) in the request headers. The MCP gateway verifies this proof before executing the search_jobs tool, ensuring providers receive immediate compensation for each query.

Can I use Agent47 with Claude Desktop or Cursor?

Yes. Any MCP-compatible client can connect to Agent47, including Claude Desktop, Cursor, Cline, and custom Node.js applications. Simply configure the client with the endpoint https://agent47.mcp.glama.ai and invoke the available tools as standard functions without platform-specific integration code.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}