How do I call Fiber AI company search?

Fiber AI’s company search is built for engineers and AI agents, so calling it is just an authenticated HTTP request to a live data API that returns fresh company records in JSON. You describe the companies you want (by size, funding, tech stack, job postings, headcount growth, etc.), Fiber does the hard work of aggregating and validating data from 100+ sources, and you only pay for successful hits.

The Quick Overview

• What It Is: A live company_search API endpoint (plus MCP support) that lets you programmatically find and filter B2B companies with far more granularity than LinkedIn or legacy data vendors.
• Who It Is For: Growth engineers, RevOps, AI agent builders, recruiters, and data teams who need precise, always-fresh B2B company lists inside their own systems and workflows.
• Core Problem Solved: “Normal” tools hide the best filters in UI-only products (LinkedIn Sales Navigator, ZoomInfo, Apollo) and return stale data. Fiber exposes those filters—and more exclusive signals—via a fast API so your outbound, recruiting, and agentic workflows don’t break.

How It Works

At a high level, Fiber AI company search is just:

1. Get an API key from your Fiber dashboard.
2. Send a POST request to the company_search endpoint with filters (e.g., headcount, funding stage, tech stack, job postings, geography).
3. Receive a JSON response with normalized company objects that you can feed into enrichment, routing, or your AI agents.

Under the hood, Fiber maps your filters into micro-queries across 100+ sources (including real-time job postings and LinkedIn signals), dedupes, and normalizes everything into one company record. Because Fiber is live, the data is continuously updated—so you can confidently trigger outbound, recruiting, or AI agent actions on top.

A typical flow to call company search looks like this:

1. Authentication:

   • Grab your API key from the Fiber AI dashboard after you create an account.
   • Pass it as a Bearer token in the Authorization header for every request.

2. Define Filters:

   • Choose filters like headcount range, headcount growth (MoM/YoY), funding stage, job posting keywords, technologies used, geography, or accelerator signals (e.g., YC companies).
   • Optionally use natural language search if you want your AI agent to describe the ICP in plain English.

3. Call the Endpoint & Page Through Results:

   • Send your filters to company_search with pagination parameters.
   • Process the returned JSON, store IDs, and optionally chain into other Fiber endpoints (e.g., people search or contact enrichment) to build complete prospect/candidate lists.

Features & Benefits Breakdown

Core Feature	What It Does	Primary Benefit
Headcount & Growth Filters	Filter by department/company headcount and MoM/YoY changes.	Target growing accounts instead of wasting time on flat orgs.
Job Posting & Tech Stack Filters	Search companies by open/closed job postings and technologies mentioned.	Find in-market accounts actively hiring for your ICP.
Natural Language / Agentic Search	Let AI agents describe companies in plain English and translate to filters.	Turn vague ICPs into precise, repeatable API queries.

Ideal Use Cases

• Best for outbound teams building target account lists: Because it lets you define companies by headcount growth, funding, job postings, and tech stack—filters that LinkedIn Sales Navigator can’t expose via API.
• Best for AI agents needing live company context: Because the company_search endpoint is API-native, continuously updated, and easy to chain into people search and contact enrichment.

How to Call Fiber AI Company Search (Step-by-Step)

1. Get API Access

1. Create an account at fiber.ai.
2. Go to your dashboard and generate an API key.
3. Store the key securely (env vars, secrets manager) and never hard-code it in client-side code.

Your requests will look like:

Authorization: Bearer YOUR_FIBER_API_KEY
Content-Type: application/json

2. Understand the Endpoint Shape

While exact paths/params may evolve, the pattern is:

• Method: POST
• Path: /v1/company_search (or equivalent as per the latest docs)
• Body: JSON with filters + pagination
• Response: JSON array of company objects plus pagination metadata

Example structure:

{
  "filters": {
    "locations": ["San Francisco Bay Area", "Seattle"],
    "employee_count_min": 50,
    "employee_count_max": 500,
    "headcount_growth_yoy_min": 0.2,
    "technologies": ["Snowflake", "dbt"],
    "funding_stage": ["Series A", "Series B"],
    "job_posting_keywords": ["RevOps", "Sales Operations"]
  },
  "limit": 50,
  "page": 1
}

3. Make a Basic company_search Call (cURL)

curl https://api.fiber.ai/v1/company_search \
  -H "Authorization: Bearer YOUR_FIBER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": {
      "locations": ["San Francisco Bay Area"],
      "employee_count_min": 20,
      "employee_count_max": 200,
      "headcount_growth_yoy_min": 0.3,
      "job_posting_keywords": ["Account Executive", "AE"],
      "funding_stage": ["Seed", "Series A"]
    },
    "limit": 50,
    "page": 1
  }'

This is the kind of query customers use to find:

• SF startups (20–200 employees)
• Growing at least 30% YoY in headcount
• Actively hiring AEs
• With early-stage funding (Seed/Series A)

4. Example in JavaScript/TypeScript

import fetch from "node-fetch";

const FIBER_API_KEY = process.env.FIBER_API_KEY!;

async function searchCompanies() {
  const res = await fetch("https://api.fiber.ai/v1/company_search", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${FIBER_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      filters: {
        locations: ["New York City"],
        employee_count_min: 100,
        employee_count_max: 1000,
        headcount_growth_mom_min: 0.05,
        job_posting_keywords: ["Data Engineer", "ML Engineer"],
        technologies: ["AWS", "Python"],
      },
      limit: 100,
      page: 1,
    }),
  });

  if (!res.ok) {
    throw new Error(`Fiber company_search failed: ${res.status} ${await res.text()}`);
  }

  const data = await res.json();
  return data;
}

searchCompanies()
  .then((data) => console.log(JSON.stringify(data, null, 2)))
  .catch(console.error);

5. Using Natural Language / Agentic Company Search

If you’re building an AI agent and don’t want to manually craft filters, you can:

1. Let the LLM take your ICP in natural language (e.g., “US-based YC-backed SaaS companies between 50–250 employees hiring Senior PMs”).
2. Map that description into Fiber’s company_search body (or use Fiber’s natural-language/agentic search if exposed in your plan).
3. Call the endpoint and iterate pagination.

Prompt-level example for your agent:

When calling Fiber AI’s company_search, convert my description into filters like locations, employee_count_min/max, funding_stage, job_posting_keywords, technologies, and headcount_growth. Don’t invent fields. Use conservative ranges if unspecified.

Features & Benefits Breakdown

Core Feature	What It Does	Primary Benefit
Headcount & Growth Filters	Filters companies by total or departmental headcount, plus YoY/MoM growth.	Prioritize fast-growing accounts with more buying intent.
Job-Posting-Based Search	Uses live job postings to infer hiring plans and tech stack.	Find companies actively investing in the roles you sell into.
Tech & Funding Signals	Filters by technologies mentioned and funding/accelerator signals (e.g., YC).	Build hyper-targeted ICP lists that other tools can’t match.

Ideal Use Cases

• Best for outbound account selection: Because you can define ideal accounts using growth, funding, jobs, and tech—then feed those IDs into people search and enrichment for full-funnel outbound.
• Best for recruiting & talent agencies: Because you can find companies hiring for specific roles, then use Fiber’s people search to pull hiring managers and decision-makers.

Limitations & Considerations

• API key & rate limits: You must authenticate every request and stay within your plan’s rate limits; higher-volume use cases should talk to us for custom limits and Slack support.
• Filter specificity: Overly narrow filters can return low volumes; start broad, inspect results, then tighten filters iteratively.

Pricing & Plans

Fiber AI uses a credit-based, success-driven model: you only pay for successful calls (data found), not for empty responses. Company search consumes credits per returned company, not per query attempt.

• Growth / Self-Serve Plan: Best for lean RevOps and product-led teams needing flexible company search with sane rate limits and the ability to plug into internal tools and workflows.
• Enterprise / Custom Plan: Best for teams building AI agents or high-volume outbound/recruiting engines that need higher rate limits, custom filters, private endpoints, and priority Slack support.

For detailed pricing and per-call credit usage, request a demo or talk to us directly.

Frequently Asked Questions

Do I need different endpoints for search vs. enrichment?

Short Answer: Yes—company search finds companies; enrichment endpoints add details to known records.
Details: Use company_search when you want to discover accounts based on filters (headcount, growth, job postings, etc.). Once you have company IDs or domains, you can pipe those into enrichment endpoints to pull deeper details or into people search to find contacts at those companies.

How does Fiber’s company search differ from LinkedIn Sales Navigator or ZoomInfo?

Short Answer: Fiber exposes more granular filters via API and is designed for agents and engineers, not just UI users.
Details: LinkedIn Sales Navigator and ZoomInfo require humans to click around in a UI and export lists; the APIs (if available) are limited. Fiber gives you programmatic access to filters like headcount growth (MoM/YoY), job-posting-based tech and role filters, accelerator/funding signals, and live LinkedIn signals. Customers routinely rip out Apollo/ZoomInfo + manual LinkedIn workflows and replace them with a company search + people search + contact enrichment pipeline powered by Fiber.

Summary

Calling Fiber AI company search is straightforward: authenticate with your API key, send a JSON body with company filters to the company_search endpoint, and programmatically page through results. Behind that simple call is a live, continuously updated data engine that gives you filters and signals legacy tools don’t expose—headcount growth, job postings, funding, tech stack, and more. That’s why teams use Fiber as the data layer under their outbound engines, recruiting stacks, and AI agents.

Next Step

Get Started