Rodz API Getting Started: Authentication and First Request

In a nutshell: The Rodz API gives you programmatic access to real-time intent data for B2B prospecting. This guide covers account creation, API key retrieval, Bearer token authentication, and a first request to list available signal types. By the end you’ll have a working setup ready to route intent signals into your sales workflow.

What Is the Rodz API? An Intent Data API for B2B Prospecting

The Rodz API is a RESTful interface that exposes intent data: the real-time context that tells you when a company is likely to need what you sell. An intent signal is the context a person or a company is in. That context conditions the problems the target is facing, and therefore the solutions they’re open to. Funding rounds, leadership changes, office relocations, hiring surges, technology adoptions and dozens of other detectable events all produce structured signals you can act on.

Static firmographic filters, industry codes and headcount ranges, tell you what a company is. Intent signals tell you what it’s going through right now. When a company raises a Series B, hires its first VP of Sales, or opens an office in a new market, that event flows through the API as a structured payload you can route into your CRM, sequencing tool, or custom application. The canonical use-case framing Rodz uses is: “I want to contact a company WHEN [signal].” The API is the mechanism that makes that conditional targeting programmable.

The API follows standard REST conventions. It accepts and returns JSON, uses Bearer token authentication, and returns predictable HTTP status codes. If you’ve worked with any modern SaaS API, the patterns here will feel familiar.

This guide covers everything you need to go from zero to your first successful API call. For the full endpoint reference, including rate limits and error codes, see the Rodz API Reference.

Prerequisites

Before you begin, make sure you have the following:

1. A Rodz account. Sign up at https://app.rodz.io/register if you don’t have one yet. The free tier gives you enough API calls to follow this tutorial and explore the platform.

2. A terminal or command-line tool. This guide uses cURL for all examples. cURL comes pre-installed on macOS and most Linux distributions. On Windows, you can use Git Bash, WSL, or PowerShell (which includes curl as an alias for Invoke-WebRequest).

3. Basic familiarity with HTTP and JSON. You should understand what a GET request is and be comfortable reading JSON responses. No advanced programming knowledge is required.

4. A text editor. Any editor works. You’ll use it to save your API key and inspect responses.

5. Optional: a REST client. Tools like Postman, Insomnia, or the VS Code REST Client extension can make exploring the API more comfortable, but they’re not required.

Step 1: Create Your Rodz Account and Get Your API Key

If you already have a Rodz account, skip to the API key retrieval step.

Create your account

Navigate to https://app.rodz.io/register and complete the registration form. You’ll need a valid business email address. After confirming your email, you’ll land on the Rodz dashboard.

Retrieve your API key

1. Log in to the Rodz dashboard at https://app.rodz.io.
2. Click on Settings in the left sidebar.
3. Navigate to the API tab.
4. Your API key is displayed under the API Key section. Click the copy icon to copy it to your clipboard.

Your API key looks something like this:

rz_live_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6

Keep this key secure. It grants full access to your Rodz account via the API. Don’t commit it to version control, share it in public channels, or embed it in client-side code. If you suspect your key has been compromised, you can regenerate it from the same settings page.

Step 2: Understand the Authentication Method

The Rodz API uses Bearer token authentication. You include your API key in the Authorization header of every HTTP request, prefixed with the word Bearer.

Here’s the header format:

Authorization: Bearer your_api_key_here

This is the same authentication pattern used by Stripe, GitHub, and most other major APIs. Every request to the Rodz API must include this header. Requests without a valid Authorization header get a 401 Unauthorized response.

There are no OAuth flows, session tokens, or multi-step handshakes. One key, one header.

Quick verification

You can verify that your API key works by making a simple request to the health check endpoint:

curl -X GET https://api.rodz.io/v1/health \
  -H "Authorization: Bearer your_api_key_here"

A successful response looks like this:

{
  "status": "ok",
  "timestamp": "2026-03-05T10:30:00Z"
}

If you see this, your API key is valid and you’re ready to make real requests.

Step 3: Make Your First API Request

With authentication confirmed, the most natural starting point is listing all available signal types. This shows you what kinds of intent signals you can track through the Rodz platform.

List available signal types

curl -X GET https://api.rodz.io/v1/signals/types \
  -H "Authorization: Bearer your_api_key_here" \
  -H "Content-Type: application/json"

Understanding the response

The API returns a JSON object containing an array of signal types. Here’s an example response:

{
  "data": [
    {
      "id": "funding_round",
      "name": "Funding Round",
      "description": "Triggered when a company raises a new round of funding.",
      "category": "financial",
      "available_filters": ["amount_min", "amount_max", "round_type", "country"]
    },
    {
      "id": "new_hire",
      "name": "New Hire",
      "description": "Triggered when a company posts new job openings or makes key hires.",
      "category": "hiring",
      "available_filters": ["department", "seniority", "country"]
    },
    {
      "id": "office_relocation",
      "name": "Office Relocation",
      "description": "Triggered when a company opens, closes, or moves an office.",
      "category": "expansion",
      "available_filters": ["country", "city"]
    },
    {
      "id": "technology_adoption",
      "name": "Technology Adoption",
      "description": "Triggered when a company adopts or drops a specific technology.",
      "category": "technology",
      "available_filters": ["technology_name", "action"]
    }
  ],
  "meta": {
    "total": 24,
    "page": 1,
    "per_page": 10
  }
}

A few things worth noting about the structure:

• data: an array of signal type objects. Each one includes an id (used in subsequent API calls), a human-readable name, a description, a category, and the available_filters you can set when configuring that signal.
• meta: pagination metadata. The total field shows how many signal types exist. page and per_page tell you where you are in the results.

Paginate through results

To see all signal types, use the page and per_page query parameters:

curl -X GET "https://api.rodz.io/v1/signals/types?page=2&per_page=10" \
  -H "Authorization: Bearer your_api_key_here" \
  -H "Content-Type: application/json"

Or pull all results at once with a larger page size:

curl -X GET "https://api.rodz.io/v1/signals/types?per_page=50" \
  -H "Authorization: Bearer your_api_key_here" \
  -H "Content-Type: application/json"

Step 4: Inspect a Specific Signal Type

Once you know which signal types are available, you can fetch details about a specific one using its id:

curl -X GET https://api.rodz.io/v1/signals/types/funding_round \
  -H "Authorization: Bearer your_api_key_here" \
  -H "Content-Type: application/json"

The response gives you the full configuration details for that signal type, including all available filters, default values, and example payloads. That’s the information you’ll need when you move on to configuring your first intent signal.

Step 5: Handle Errors Gracefully

The Rodz API uses standard HTTP status codes and returns structured error messages in JSON format. Here are the errors you’re most likely to run into.

401 Unauthorized - Your API key is missing, invalid, or expired.

{
  "error": {
    "code": "unauthorized",
    "message": "Invalid or missing API key. Please check your Authorization header.",
    "status": 401
  }
}

Fix: double-check that your Authorization header includes the Bearer prefix and that the key itself is correct. The most common mistake is dropping the space between Bearer and the key.

403 Forbidden - Your API key is valid, but you don’t have permission to access the requested resource.

{
  "error": {
    "code": "forbidden",
    "message": "Your current plan does not include access to this resource.",
    "status": 403
  }
}

Fix: this usually means the endpoint or signal type requires a higher-tier plan. Check your subscription in the Rodz dashboard or contact the team to discuss your options.

429 Too Many Requests - You’ve exceeded the rate limit.

{
  "error": {
    "code": "rate_limit_exceeded",
    "message": "Rate limit exceeded. Please retry after 60 seconds.",
    "status": 429,
    "retry_after": 60
  }
}

Fix: implement exponential backoff in your integration. The retry_after field tells you exactly how many seconds to wait before retrying. Rate limits by plan are documented in the API Reference.

Best practices for error handling

Always check the HTTP status code before parsing the response body. A 2xx status means success; anything else means something went wrong. Log error responses, including the code and message fields, since they’re written to be human-readable and will speed up debugging.

Implement retry logic for 429 and 5xx errors, using exponential backoff with jitter to avoid thundering herd problems. Don’t retry 401 or 403 errors automatically. Those need a configuration fix, not a retry.

Step 6: Where to Go From Here

You now have a working connection to the Rodz API. Here’s the recommended path to a complete integration:

1. Configure your first signal. Follow the Configure Your First Intent Signal guide to set up a signal that watches for funding rounds, new hires, or any event that matters to your prospecting workflow.

2. Set up real-time delivery. Instead of polling the API, configure webhooks to receive signals the moment they fire. The Real-Time Intent Signals: Set Up Rodz Webhooks guide walks you through the process.

3. Explore the full API reference. The Rodz API Reference covers every endpoint, all request and response schemas, rate limits, and advanced filtering options.

4. Read the Rodz blog. The Rodz blog covers intent-based prospecting strategies, industry use cases, and practical tips for getting more out of your intent data.

Frequently Asked Questions

What programming languages can I use with the Rodz API?

Any language that can make HTTP requests works. The examples here use cURL, but Python (requests or httpx), JavaScript (fetch or axios), Ruby, Go, PHP, Java, and anything else that speaks HTTP will work fine. The API communicates over standard HTTP with JSON payloads, so there’s no language-specific dependency.

Is there an SDK or client library available?

The API is designed to be straightforward enough that you don’t need a dedicated SDK. Client libraries for popular languages are on the roadmap. For now, a simple HTTP wrapper function in your language of choice is all you need.

How do I keep my API key secure?

Store your API key in environment variables, not in source code. Most deployment platforms (Vercel, Railway, AWS, etc.) support environment variables natively. In local development, use a .env file and make sure it’s listed in your .gitignore. Never log your API key or pass it as a URL query parameter.

What are the rate limits?

Rate limits depend on your plan. The free tier allows enough requests for development and testing. Production plans offer higher throughput. The exact limits are in the API Reference. If you hit a rate limit, the API responds with a 429 status code and a retry_after field indicating when it’s safe to retry.

Can I use the API in a staging or test environment?

Yes. Your API key works in both development and production contexts. If you want to avoid affecting production configurations while testing, create signal configurations with a test-specific naming convention and delete them when you’re done.

What happens if the API is down?

The Rodz API is monitored around the clock, and outages are communicated proactively. In your integration, implement retry logic with exponential backoff for 5xx errors. For mission-critical use cases, consider caching recent responses locally so your workflow keeps running if the API is temporarily unreachable.

How do I get support if I’m stuck?

The fastest path is to book a call with the Rodz team. You can also browse the interactive API documentation at https://api.rodz.io/docs, which includes live request builders and response previews.

Can I use the Rodz API alongside my existing CRM?

Yes. Most teams push intent data into their CRM (HubSpot, Salesforce, Pipedrive, etc.) via custom integrations or automation platforms like Make. Once intent signals are flowing through the API, routing them to your CRM is a matter of mapping fields and triggering the right actions. The API is built to sit inside an existing stack, not replace it.

Start Building

The Rodz API gives you access to 108 distinct real-time intent signals. A signal fires the moment the underlying context changes at a target account, and that window is short: inside 48 hours, reply rates run 4x cold-outbound levels. After that, the signal decays back toward cold-list efficacy. Getting the data programmatically, rather than pulling a weekly export, is what keeps the timing intact.

Two resources to keep bookmarked:

• Interactive API documentation for exploring endpoints, testing requests, and reading detailed schema definitions.
• Book a call if you want help designing your integration or figuring out which signals are most relevant for your business.