Search the Developer Index

Search the developer index

curl --request GET \
  --url https://api.firecrawl.dev/v2/search/developer \
  --header 'Authorization: Bearer <token>'

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.firecrawl.dev/v2/search/developer', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.firecrawl.dev/v2/search/developer",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.firecrawl.dev/v2/search/developer"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.firecrawl.dev/v2/search/developer")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

{
  "success": true,
  "results": [
    {
      "id": "issue:firecrawl/firecrawl#1234",
      "type": "issue",
      "url": "https://github.com/firecrawl/firecrawl/issues/1234",
      "title": "Retries are not applied to 429 responses",
      "passages": [
        {
          "text": "The client treats 429 as a terminal status, so the backoff never runs."
        }
      ]
    }
  ],
  "coverage": {
    "doc": "ok",
    "issue": "ok",
    "pull_request": "ok",
    "readme": "ok"
  },
  "reranked": true
}

GET

developer

Search the developer index

curl --request GET \
  --url https://api.firecrawl.dev/v2/search/developer \
  --header 'Authorization: Bearer <token>'

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.firecrawl.dev/v2/search/developer', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.firecrawl.dev/v2/search/developer",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.firecrawl.dev/v2/search/developer"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.firecrawl.dev/v2/search/developer")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

{
  "success": true,
  "results": [
    {
      "id": "issue:firecrawl/firecrawl#1234",
      "type": "issue",
      "url": "https://github.com/firecrawl/firecrawl/issues/1234",
      "title": "Retries are not applied to 429 responses",
      "passages": [
        {
          "text": "The client treats 429 as a terminal status, so the backoff never runs."
        }
      ]
    }
  ],
  "coverage": {
    "doc": "ok",
    "issue": "ok",
    "pull_request": "ok",
    "readme": "ok"
  },
  "reranked": true
}

Search GitHub issues, merged pull requests, repository READMEs, and curated documentation sites. Results are ranked and carry the matched passages in markdown. POST is available on the same path when you want to pass array filters as JSON. Repeatable filters accept either form on GET: a repeated query parameter such as types=issue&types=pull_request, or one comma separated value such as types=issue,pull_request.

How `repos` and `sources` scope a search

The index has two halves, and these two filters scope them independently:

repos scopes the GitHub half, meaning the issue, pull_request, and readme types
sources scopes the documentation half, meaning the doc type
Passing both combines the two halves rather than intersecting them, so you get matching results from either

Because each filter only applies to one half, a filter that cannot match any requested type is rejected rather than silently returning nothing:

repos with no GitHub type in types returns 400 with repos cannot match any requested type; add github types or drop repos
sources with no doc in types returns 400 with sources cannot match any requested type; add doc or drop sources

How the repository filters scope a search

The seven repository filters — language (such as Rust), topic (such as async), license (such as MIT), min_stars, max_stars, archived, and fork — describe a GitHub repository. Most documentation pages in the index come from a crawled website with no repository behind it, and no repository fact can admit or exclude such a page. A request that sends one of these filters and no sources scope therefore gets no doc results. Its response holds GitHub evidence only: the issue, pull_request, and readme types. The coverage map reports doc as unavailable, because the documentation half of the index never ran. This is the design, not an index fault. To keep documentation results, drop the repository filters. You can also scope the documentation half with sources, then read coverage to confirm that the doc type answered.

# No API key needed to get started; add -H "Authorization: Bearer $FIRECRAWL_API_KEY" for higher rate limits:
curl -s "https://api.firecrawl.dev/v2/search/developer?query=how%20do%20I%20configure%20retries&k=10&language=Rust&license=MIT"

curl -X POST https://api.firecrawl.dev/v2/search/developer \
  -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "how do I configure retries",
    "k": 10,
    "types": ["issue", "pull_request"],
    "language": "Rust",
    "license": "MIT"
  }'

Which values `sources` accepts

sources is not a fixed enum. It takes documentation source ids, each a nonempty string of at most 512 characters, and at most 20 per request. The ids reflect the documentation sites in the index, and the set grows over time. To confirm an id resolves, pass it and read the sources array the response adds. It appears only when you sent sources, and reports each id exactly as you requested it along with whether it is indexed:

{
  "success": true,
  "results": [],
  "sources": [
    { "source": "some-docs-site", "indexed": true },
    { "source": "unknown-docs-site", "indexed": false }
  ]
}

indexed: true means the source has a published generation, so documentation evidence from it may appear. indexed: false means nothing from that id can match, which distinguishes an id that is not in the index from a query that simply found nothing. repos echoes back the same way, as a repos array reporting indexed plus a per type breakdown under types:

{
  "success": true,
  "results": [],
  "repos": [
    {
      "repo": "firecrawl/firecrawl",
      "indexed": true,
      "types": { "issue": true, "pullRequest": true, "readme": true }
    }
  ]
}

Reading `coverage`

coverage reports the outcome for each result type, one of ok, degraded, unavailable, or skipped. Check it when a result type you expected is missing:

skipped means your types value did not ask for that type
degraded or unavailable means the gap came from the index or from a filter, not from the query. A repository filter is one such cause, as how the repository filters scope a search describes

For a workflow overview, see the Developer Index guide.

Authorizations

Authorization

string

header

required

Bearer authentication header of the form Bearer <token>, where <token> is your auth token.

Query Parameters

query

string

required

Natural-language question or search phrase.

Minimum string length: 1

integer

default:10

Number of ranked results to return.

Required range: 1 <= x <= 100

types

enum<string>[]

Result kinds to search. Defaults to all four. Accepts a repeated parameter (types=issue&types=pull_request) or one comma-separated value (types=issue,pull_request).

Available options:

doc,

issue,

pull_request,

readme

repos

string[]

Repository slugs to scope the GitHub half of the index to, such as firecrawl/firecrawl. Applies to the issue, pull_request, and readme types only. Sent together with sources, the two halves are combined rather than intersected, so matching results come back from either. Returns 400 with repos cannot match any requested type; add github types or drop repos when no GitHub type is in types.

sources

string[]

Documentation source ids to scope the documentation half to, at most 20. Applies to the doc type only. Not a fixed enum: ids reflect the documentation sites in the index and the set grows over time, so confirm an id resolves by sending it and reading the sources array on the response. Returns 400 with sources cannot match any requested type; add doc or drop sources when doc is not in types.

Maximum array length: 20

Required string length: 1 - 512

skills

enum<string>

Set to only to limit the search to indexed agent-skill files.

Available options:

only

passages

integer

default:1

Matched passages to return per result.

Required range: 1 <= x <= 5

language

string

Repository primary language, such as Rust. Applies to GitHub results only; sending it with no sources scope returns no doc results. See how the repository filters scope a search.

Example:

"Rust"

topic

string

Repository topic, such as async. Applies to GitHub results only; sending it with no sources scope returns no doc results.

Example:

"async"

license

string

Repository license, such as MIT. Applies to GitHub results only; sending it with no sources scope returns no doc results.

Example:

"MIT"

min_stars

integer

Lower bound on repository stars. Applies to GitHub results only; sending it with no sources scope returns no doc results.

Required range: x >= 0

max_stars

integer

Upper bound on repository stars. Applies to GitHub results only; sending it with no sources scope returns no doc results.

Required range: x >= 0

archived

boolean

Include or exclude archived repositories. Applies to GitHub results only; sending it with no sources scope returns no doc results.

fork

boolean

Include or exclude forks. Applies to GitHub results only; sending it with no sources scope returns no doc results.

Response

Ranked developer results with matched passages.

success

boolean

results

object[]

Show child attributes

coverage

object

Outcome for each result type. Check this when an expected result type is missing: skipped means your types value did not ask for that type, while degraded or unavailable means the gap came from the index or from a filter, not from the query. A repository filter is one such cause — see how the repository filters scope a search.

Show child attributes

reranked

boolean

Whether the ranked list went through the reranking stage.

repos

object[]

Present only when repos was sent. Echoes each slug with whether it is indexed, plus a per-type breakdown under types.

Show child attributes

Example:

[
  {
    "repo": "firecrawl/firecrawl",
    "indexed": true,
    "types": {
      "issue": true,
      "pullRequest": true,
      "readme": true
    }
  }
]

sources

object[]

Present only when sources was sent. Reports each id exactly as requested along with whether it is indexed. indexed: true means the source has a published generation, so documentation evidence from it may appear; indexed: false means nothing from that id can match, which distinguishes an id that is not in the index from a query that simply found nothing.

Show child attributes

Example:

[
  {
    "source": "some-docs-site",
    "indexed": true
  },
  {
    "source": "unknown-docs-site",
    "indexed": false
  }
]

Using the API

Search Endpoints

Scrape Endpoints

Interact Endpoints

Research Index Endpoints

Developer Index Endpoints

Map Endpoints

Parse Endpoints

Crawl Endpoints

Monitor Endpoints

Feedback Endpoints

Agentic Debugging Endpoints

Account Endpoints

Webhook Payloads

Partner Integration

Search the Developer Index

How `repos` and `sources` scope a search

How the repository filters scope a search

Which values `sources` accepts

Reading `coverage`

Authorizations

Query Parameters

Response

​How repos and sources scope a search

​How the repository filters scope a search

​Which values sources accepts

​Reading coverage

Authorizations

Query Parameters

Response

How `repos` and `sources` scope a search

How the repository filters scope a search

Which values `sources` accepts

Reading `coverage`