Build a Research Brief with Firecrawl

Turn web, PDF, and podcast sources into an agent-ready Markdown brief.

Introduction

30 Second Summary

Useful evidence rarely lives in one neat place. A key detail might sit on a web page while the supporting context hides in a PDF or podcast episode.

In this project, you will build a Node.js script that gathers research through Firecrawl. One run turns three source types into a Markdown brief for an AI agent.

What You'll Build

One run produces brief.md, where evidence from the page, the PDF, and relevant podcast episodes sits in clear sections ready for your next question.

By the end of this project, you'll have:

A reusable three-source workflow that gathers evidence from a web page, a PDF, and podcast episodes.
A single research brief in brief.md with a clearly labeled section for every source.
A cross-source answer from a chat model that cites the page, the PDF, and an episode.
Secret Mission: An optional challenge to push your skills further.

Are there any prerequisites?

You'll need Node.js, a free Firecrawl account, and a Firecrawl API key. No previous web scraping experience is required.

Before We Start

Your research brief eventually pulls three source types through Firecrawl. Those calls travel as HTTP requests from your computer.

In this step, you'll prepare Visual Studio Code, Node.js, and curl. Together, these tools give you a complete local workspace.

In this step, get ready to:

Prepare Visual Studio Code for the brief.
Install Node.js for running the brief-building script.
Confirm curl can send requests from your terminal.

Set up your code editor

Your finished research brief will be a Markdown file that combines every source. A code editor gives you one place to write the script and inspect that file.

Press Cmd+Space (macOS) or the Windows key (Windows) to open your search bar.
Type Visual Studio Code into the search bar.
Press Enter to launch the editor.

✔️ Visual Studio Code opens

Your editor is ready. You now have a place to write the script and inspect the finished brief.

ⓧ It is not installed yet

Install Visual Studio Code from its official download page. Choose the tab for your operating system.

macOS

Visit the official Visual Studio Code download page.
Download the Universal .dmg file.
Open the downloaded .dmg file.
Drag Visual Studio Code.app into the Applications folder.
Press Cmd+Space to open Spotlight.
Type Visual Studio Code into Spotlight.
Press Enter to launch the editor.

Windows

Visit the official Visual Studio Code download page.
Download the User Installer that matches your device.
Run the downloaded installer.
Follow the installer prompts.
Press the Windows key to open search.
Type Visual Studio Code into search.
Press Enter to launch the editor.

You should now see an empty Visual Studio Code window. That confirms your editor is ready for the project.

Check Node.js

Node.js runs the JavaScript script that assembles your brief. A version check tells you whether the runtime is already available.

Press Cmd+Space (macOS) or the Windows key (Windows) to open your search bar.
Type Terminal on macOS or Windows Terminal on Windows.
Press Enter to open the terminal.
Check whether Node.js is installed by running:

node --version

What does this command do?

The version check asks the node executable to print its installed release. A version number confirms that your terminal can find Node.js.

✔️ I see a Node.js version

Good start. Node.js is installed and available from your terminal.

ⓧ Node.js is not installed yet

The official installer includes the runtime needed for this project. It also configures your system so the terminal can find Node.js.

Visit the official Node.js download page.
Select the LTS release.
Download the Installer for your operating system.
Run the downloaded installer.
Approve your operating system's permission request if it appears.
Complete the installer with its default options.

The installer updates the system path used by new terminal windows. A fresh terminal picks up that change.

Close your current terminal.
Repeat the operating system search steps above to open a fresh terminal.
Repeat the Node.js version check from above.

You should now see a Node.js version number in the terminal.

Still Missing the Node.js Version?

Make sure you opened a fresh terminal after the installation completed. An older terminal window may still be using the previous system path.

If your device is managed by a school or workplace, installation permissions may block the runtime. Help me check why Node.js is still unavailable after installation.

Confirm curl is available

The curl command sends requests directly from your terminal. You use it to inspect Firecrawl responses before writing the full script.

Switch back to the terminal from your Node.js check.

Before you check, do you expect the terminal to recognize curl immediately?

Check whether curl is available by running:

curl --version

What does this command do?

This check asks the curl executable to describe its installed release. The output also lists the request features available on your computer.

✔️ I see a curl version

That's your network tool ready. The first output line begins with curl followed by a version number.

ⓧ curl is not installed yet

The official curl download hub lists packages for each supported platform. Choose the tab for your operating system.

macOS

Visit the official curl download page.
Find the macOS section.
Select the package that matches your platform.
Follow the linked package provider's installation instructions.
Close your current terminal.
Repeat the operating system search steps from the Node.js check to open a fresh terminal.
Repeat the curl version check from above.

Windows

Visit the official curl for Windows page.
Select the package that matches your platform.
Download the package.
Follow the installation instructions provided with the package.
Close your current terminal.
Repeat the operating system search steps from the Node.js check to open a fresh terminal.
Repeat the curl version check from above.

Still Missing the curl Version?

Confirm that you opened a fresh terminal after installing curl. The new terminal needs access to the location where the package was installed.

If the check still fails, help me find why curl is unavailable in my terminal.

Your local toolkit is ready. Visual Studio Code can hold the project files.

Node.js can run the script. curl can test the requests that feed your research brief.

Your computer is ready for the build. Next, you'll create your Firecrawl account and get access to the API.

Create Your Firecrawl Account

Your research brief needs access to Firecrawl before it can fetch any source. The account supplies that access.

In this step, you'll create a free account. You'll copy its API key into secure storage.

You'll also record the starting credit balance. That number becomes the baseline for later usage checks.

In this step, get ready to:

Create a free Firecrawl account.
Copy your Firecrawl API key into secure storage.
Record your starting credit balance.

Create your free account

New accounts start on the free plan. The plan requires no payment card.

The free plan includes 1,000 credits for each monthly cycle. This gives you room to complete the project without entering billing details.

Open the Firecrawl sign-up page in your browser.
Select one of the account methods shown on the page.
Complete the provider's sign-in flow.
Approve the identity provider's sign-in request if one appears.

You're in. The Firecrawl dashboard is now the control center for your account.

You should see dashboard navigation entries for API Keys plus Usage.

Dashboard not loading?

Return to the Firecrawl sign-up page in the same browser profile.
Complete any unfinished verification shown by your identity provider.

Help me finish signing in to Firecrawl.

Secure your API key

The next screen exposes a credential that can authorize requests against your credit balance. You stay in control because the key only goes into your secure storage.

Select API Keys in the dashboard navigation.
Locate the active key created for your account.
Copy its value using the copy icon beside the key.
Save the copied value as a secure note in your password manager.
Close the credential view if the full key remains visible.
Keep the full key out of every screenshot in this project.

You should now see at least one active key on the API Keys page.

Why does the key need protection?

The key authenticates requests as your Firecrawl account. Anyone who has it can spend your credits.

Secure storage keeps the credential outside anything you share.

Can't find an active key?

Refresh the API Keys page once.
Use the page's key creation control if the list is empty.

Help me find or create my Firecrawl API key.

Record your starting credit balance

Credits measure your Firecrawl usage. Your starting balance gives you a clean comparison point for every request that follows.

Before you check the total, do you expect this new account to show any consumed project credits?

Select Usage in the dashboard navigation.

You should see 1,000 credits in the free plan's monthly allocation. You should see no project consumption yet.

Record the available credit balance shown on the page: your starting credit balance.

That's your account access secured plus your usage baseline captured. Next, you'll use curl to scrape a web page and read the returned markdown.

Scrape a Web Page

Your Firecrawl account is ready. The API key you copied gives your terminal permission to send an authenticated request.

Most web pages mix useful text with navigation or page chrome. Firecrawl can return the page as Markdown for a cleaner research brief.

In this step, get ready to:

Load your Firecrawl API key into the current terminal session.
Send an authenticated scrape request with curl.
Review the returned Markdown in your terminal.

Prepare terminal authentication

An environment variable lets curl read your API key by name. Your key remains available to commands in this terminal session.

Keep your credential private

Credentials deserve extra care. Closing this terminal clears the session value.

Keep the API key setup line out of screenshots.
Avoid sharing your terminal history while the key is present.

Switch back to the terminal from the previous step.
Paste your copied Firecrawl API key over fc-your-api-key in the command below.
Load the key into the current terminal session by running the edited command:

export FIRECRAWL_API_KEY="fc-your-api-key"

What does this command do?

The export command makes the value available to commands started from this terminal.
The name FIRECRAWL_API_KEY lets the scrape request use your key without placing its value in the request body.

Key not loading?

Confirm that you replaced the entire fc-your-api-key placeholder with the key you copied.
Use the same terminal session for the scrape request.

Help me check why my Firecrawl API key is not available in my terminal session.

Scrape and review the page

The /v2/scrape endpoint accepts the web page you want to collect. Its formats array tells Firecrawl to return the content as markdown.

Before you run this request, where do you expect the page text to appear in the response?

Send the Firecrawl documentation page to the scrape endpoint by running this command:

curl -X POST "https://api.firecrawl.dev/v2/scrape" \
  -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://docs.firecrawl.dev",
    "formats": ["markdown"]
  }'

What does this command do?

The -X POST option sends data to the scrape endpoint.
The Authorization header authenticates the request with your API key.
The Content-Type header identifies the request body as JSON.
The request body selects https://docs.firecrawl.dev as the source page.
The formats value requests Markdown output.

You'll see a JSON response with success set to true. Inside data, the markdown field contains the page text.

Scroll through the response in your terminal.
Find the markdown field inside the data object.
Read the opening heading from the returned page content.
Locate sourceURL inside the metadata object.
Confirm that sourceURL points to the Firecrawl documentation page.
Scroll until the API key setup line is out of view.
Keep the returned markdown field visible for your checkpoint.

You have your first research source. Firecrawl has converted the chosen web page into Markdown that your future brief can use.

Scrape request not succeeding?

Run the API key export command again if the response reports an authentication problem.
Confirm that the Firecrawl documentation page opens in your browser if the response contains no page content.
Check that every quote in the request matches the command above if your terminal cannot parse it.

Help me debug my Firecrawl web page scrape without exposing my API key.

Your first source is now readable through one scrape endpoint. Next, you'll prove that the same endpoint can turn a PDF into Markdown.

Scrape a PDF

Your web page scrape proved that Firecrawl can turn a public URL into Markdown. The next source for your research brief is a published document.

A PDF often holds detailed evidence that a web page leaves out. You will send one to the same API endpoint to keep your collection process consistent.

In this step, get ready to:

Choose a public PDF related to your research topic.
Submit the PDF URL to Firecrawl's scrape endpoint.
Review the extracted document text as Markdown.

Choose a public PDF

Firecrawl needs a URL that it can access directly. Opening the document first confirms that the PDF is publicly available.

Open a new browser tab.
Use the browser's address bar to search for a public PDF that supports your research topic.
Open a result that links directly to the PDF.

You should see the PDF pages without a sign-in prompt. This confirms that Firecrawl can reach the document.

Record the full PDF URL here: https://example.com/report.pdf.

Scrape the PDF as Markdown

The scrape endpoint detects documents from their URLs. Requesting the Markdown format tells Firecrawl to return the extracted document text in the same format as your web page.

Before you run the request, do you think the PDF needs a different endpoint from the web page?

Return to the terminal from your web page scrape.
Replace fc-YOUR-API-KEY in the request below with your securely copied Firecrawl API key.
Submit your PDF URL to the scrape endpoint by running this request:

curl --request POST \
  --url https://api.firecrawl.dev/v2/scrape \
  --header 'Authorization: Bearer fc-YOUR-API-KEY' \
  --header 'Content-Type: application/json' \
  --data '
{
  "url": "[[PDF_URL="https://example.com/report.pdf"]]",
  "formats": [
    "markdown"
  ]
}
'

What does this request do?

The endpoint stays unchanged from your web page scrape. The url field now points to your public PDF.
The formats field requests markdown output from the document.
The authorization header proves that the request belongs to your Firecrawl account.
The endpoint returns a JSON response. The extracted document text appears in data.markdown.

Scroll through the data.markdown value in your terminal.
Find a heading that also appears in the original PDF.
Find a sentence that also appears in the original PDF.

You should see success set to true. You should also see readable document text inside data.markdown.

That is your second source collected. The same Firecrawl endpoint now handles both a web page and a PDF.

PDF text missing?

Confirm that you replaced fc-YOUR-API-KEY with your copied API key.
Check that the PDF URL still opens without requesting a sign-in.
Confirm that the recorded URL points to the PDF document.

Help me troubleshoot my PDF scrape.

Scroll until the request command is outside the terminal view.
Keep the extracted PDF Markdown visible for your checkpoint.

Your research flow now covers a web page plus a PDF. Next, you will bring podcast episodes into the same collection process.

Search Podcast Episodes

Your web page scrape returned readable markdown through Firecrawl. Your PDF scrape proved the same endpoint can handle a document.

Now your research brief needs voices from podcasts. Alexandria routes podcast searches to the Particle provider. Particle requires provider terms to be accepted before the request can run.

In this step, get ready to:

Accept Particle's provider terms for your Firecrawl organization.
Call podcasts/episodes/search for your chosen topic.
Confirm the response contains matching podcast records as JSON.

Accept the Particle provider terms

The provider agreement controls organization access to Particle's records. An organization admin must accept it before Firecrawl can execute the podcast capability.

Accepting these terms changes access for your whole Firecrawl organization. The agreement stays visible before confirmation so you can review the access being granted.

Switch back to the browser tab with your Firecrawl dashboard.
Visit the Data sources settings page to open your organization's provider settings.
Find the Particle provider card.
Open the provider terms shown on the Particle card.
Review the provider terms.
Use the confirmation control shown with the terms to accept them.
Confirm the Particle card indicates that the terms are accepted.

That's the access gate cleared. Your Firecrawl organization can now request podcast records from Particle.

Can't accept the terms?

Ask an organization admin to accept the Particle terms if the confirmation control is unavailable.
Confirm the dashboard is showing the same Firecrawl organization that owns your API key.

Need help checking your organization access? Help me work out why I cannot accept the Particle provider terms in my Firecrawl organization.

Call the podcast search capability

The request still goes to Firecrawl's /scrape endpoint. Its request body selects Particle's podcasts/episodes/search capability.

This call spends Firecrawl credits at the tool's listed price. You are making one focused request before you automate the search in your script.

The authorization header contains your credential after you replace the placeholder. Your checkpoint captures only the response so the API key stays outside the screenshot.

Switch back to the terminal from your earlier scrapes.
Replace fc-YOUR_API_KEY in the request below with your copied Firecrawl API key.
Replace AI agents with your chosen research topic.

Before you run this, which response do you expect: page markdown or structured podcast records?

Send the podcast search request by running this command:

curl -X POST https://api.firecrawl.dev/v2/scrape \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -d '{
    "alexandria": {
      "provider": "particle",
      "capability": "podcasts/episodes/search",
      "options": { "semantic_search": "AI agents", "limit": 2 }
    }
  }'

What does this request do?

The alexandria object routes the scrape request to a structured data provider.
The provider value selects Particle.
The capability value selects podcast episode search.
The semantic_search option describes the topic you want to find.
The limit option requests two matching records.

You should see a response with success set to true. The response contains structured podcast results under data.alexandria.

Scroll through the returned JSON.
Find the data.alexandria array.
Inspect the first Alexandria result item.
Confirm the item contains a data value.
Confirm the item does not contain an error value.
Review the returned episode records or matching passages for your chosen topic.

The same endpoint has now returned web content, PDF text, and podcast records. Your episode search is ready to become the third source in the research brief.

Podcast results missing?

Return to the Data sources settings page if the response contains THIRD_PARTY_DATA_TERMS_REQUIRED.
Confirm Particle shows accepted terms for the current Firecrawl organization.
Check that fc-YOUR_API_KEY was replaced with your Firecrawl API key.
Use a broader phrase for semantic_search if Particle returns no matching records.

Need help reading the response? Help me debug my Firecrawl Particle podcast search response.

Frame only the returned JSON in your screenshot.
Keep the request command outside the screenshot.

Your research now reaches web pages, PDFs, and podcast episodes through one Firecrawl endpoint. Next, you'll combine all three calls in one Node.js script. That script writes your research brief.

Build Your Research Brief Script

That is the source-gathering work done. Firecrawl can return a web page as Markdown. It can extract a PDF through the same interface.

In this step, you will use Node.js to collect all three results in one run. Your script will turn them into a reusable research brief.

In this step, get ready to:

Create a project folder with the Firecrawl SDK.
Write a script that collects the web page, PDF and podcast results.
Run the script and verify that every source appears in brief.md.

Set up the project folder

A dedicated folder keeps the script beside its generated brief. The Firecrawl SDK gives your script the same scrape interface you used for each source.

Switch back to your terminal.
Move to your Desktop by running this command:

cd ~/Desktop

Your terminal now uses the Desktop as its starting location.

Create the research-brief folder and move into it by running these commands:

mkdir research-brief
cd research-brief

Your terminal prompt now points to the new research-brief folder.

Install the Firecrawl SDK by running:

npm install firecrawl

The installation can take a minute while npm downloads the package. You will see an installation summary when it finishes.

Firecrawl package not installing?

Confirm that your terminal still points to the research-brief folder. A network or package registry problem can also interrupt the download.

Help me diagnose the Firecrawl installation failure.

The script reads your credential from FIRECRAWL_API_KEY. Your key stays in the current terminal session. It never enters research-brief.js.

macOS

Replace fc-YOUR-API-KEY with the Firecrawl API key you copied earlier.
Load the key into your current terminal session by running:

export FIRECRAWL_API_KEY=fc-YOUR-API-KEY

The terminal now supplies the key to processes started from this session. Keep this terminal open for the final run.

Windows

Replace your-placeholder-value with the Firecrawl API key you copied earlier.
Load the key into your current PowerShell session by running:

$Env:FIRECRAWL_API_KEY = "your-placeholder-value"

PowerShell now supplies the key to processes started from this session. Keep this terminal open for the final run.

Write the research brief script

Each source returns a different shape. The script keeps the page and PDF as Markdown. It stores the podcast episode list as formatted JSON.

Press Cmd+Space (macOS) or the Windows key (Windows) to open your app search.
Type the name of your installed code editor into the search field.
Press Enter to launch the editor.
Use the editor's folder-opening option to select the research-brief folder on your Desktop.
Create a file named research-brief.js inside the folder.
Add the three source calls and brief writer by pasting this code into research-brief.js:

const fs = require("node:fs/promises");
// Store the subject and source URLs used in the brief.
const topic = "[[TOPIC="your chosen research topic"]]";
const pageUrl = "[[WEB_PAGE_URL="https://example.com/article"]]";
const pdfUrl = "[[PDF_URL="https://example.com/report.pdf"]]";
async function buildBrief() {
  // Load the SDK and authenticate with the terminal environment.
  const { Firecrawl } = await import("firecrawl");
  const firecrawl = new Firecrawl({ apiKey: process.env.FIRECRAWL_API_KEY });
  // Collect the page, document and podcast material.
  const page = await firecrawl.scrape(pageUrl, { formats: ["markdown"] });
  const pdf = await firecrawl.scrape(pdfUrl, { formats: ["markdown"] });
  const episodes = await firecrawl.scrape({
    alexandria: {
      provider: "particle",
      capability: "podcasts/episodes/search",
      options: { semantic_search: topic, limit: 2 },
    },
  });
  // Turn every result into one markdown document.
  const brief = `# Research Brief: ${topic}\n\n## Web Page\n\n${page.markdown}\n\n## PDF\n\n${pdf.markdown}\n\n## Podcast Episodes\n\n\`\`\`json\n${JSON.stringify(episodes.alexandria[0].data, null, 2)}\n\`\`\`\n`;
  await fs.writeFile("brief.md", brief, "utf8");
  console.log("Created brief.md.");
}
// Surface any failed request in the terminal.
buildBrief().catch((error) => { console.error(error); process.exitCode = 1; });

What does this code do?

The three configuration values hold your topic and the two URLs you tested earlier.
The first two firecrawl.scrape() calls request Markdown from the web page and PDF.
The third firecrawl.scrape() call sends your topic to Particle's podcasts/episodes/search capability.
The script reads the episode data from episodes.alexandria[0].data.
The final section combines all three results before writing brief.md.

Save research-brief.js by pressing Cmd+S (macOS) or Ctrl+S (Windows).

You should see research-brief.js listed inside the research-brief folder in your editor.

✔️ Awesome, I've got everything!

Your source settings and three Firecrawl calls are ready. Double check that research-brief.js is saved before continuing.

ⓧ I'd like to double check the full code

Compare your complete research-brief.js file with this reference:

const fs = require("node:fs/promises");
// Store the subject and source URLs used in the brief.
const topic = "[[TOPIC="your chosen research topic"]]";
const pageUrl = "[[WEB_PAGE_URL="https://example.com/article"]]";
const pdfUrl = "[[PDF_URL="https://example.com/report.pdf"]]";
async function buildBrief() {
  // Load the SDK and authenticate with the terminal environment.
  const { Firecrawl } = await import("firecrawl");
  const firecrawl = new Firecrawl({ apiKey: process.env.FIRECRAWL_API_KEY });
  // Collect the page, document and podcast material.
  const page = await firecrawl.scrape(pageUrl, { formats: ["markdown"] });
  const pdf = await firecrawl.scrape(pdfUrl, { formats: ["markdown"] });
  const episodes = await firecrawl.scrape({
    alexandria: {
      provider: "particle",
      capability: "podcasts/episodes/search",
      options: { semantic_search: topic, limit: 2 },
    },
  });
  // Turn every result into one markdown document.
  const brief = `# Research Brief: ${topic}\n\n## Web Page\n\n${page.markdown}\n\n## PDF\n\n${pdf.markdown}\n\n## Podcast Episodes\n\n\`\`\`json\n${JSON.stringify(episodes.alexandria[0].data, null, 2)}\n\`\`\`\n`;
  await fs.writeFile("brief.md", brief, "utf8");
  console.log("Created brief.md.");
}
// Surface any failed request in the terminal.
buildBrief().catch((error) => { console.error(error); process.exitCode = 1; });

Run and inspect the brief

This run deducts Firecrawl credits for the three requests. It sends only the calls defined in your script.

Before you run it, which three source headings do you expect to find in the finished brief?

Return to the terminal where you loaded FIRECRAWL_API_KEY.
Generate the research brief by running:

node research-brief.js

You should see Created brief.md. in the terminal. That message confirms that all three calls finished before the file was written.

Return to your code editor.
Select brief.md from the folder sidebar.

You should see the headings Web Page, PDF and Podcast Episodes.

The first section contains material from your chosen page. The second contains extracted PDF text. The final section contains the returned Alexandria episode records.

Brief not created?

If authentication fails, load your Firecrawl API key again in the same terminal session that runs the script.
If a source section is empty, confirm that its URL in research-brief.js matches the URL you tested earlier.
If the podcast request fails, confirm that the terminal uses the key from the organization where you accepted the Particle terms.

Help me debug my research brief script.

Your research brief now brings a web page, a PDF and podcast episodes into one file. Next, you will give brief.md to a chat model and ask a question that needs every source.

Ask Questions Across Your Sources

The finished brief.md now holds all three source types. The combined file is ready for a real research test.

A chat model can connect claims found across the brief. This step tests that synthesis with a question whose answer depends on every source type.

In this step, get ready to:

Paste the complete brief.md into a chat model.
Write a question that depends on all three source types.
Verify that the answer cites every source type.

Paste the complete brief

The model needs the full source text in one conversation. This shared context lets it connect evidence from separate sections.

Open the web app for the chat model you use.
Use the app's new-conversation control to start with an empty message field.
Switch back to the brief.md tab from earlier.
Select the complete file with Cmd+A (macOS) or Ctrl+A (Windows).
Copy the selected content with Cmd+C (macOS) or Ctrl+C (Windows).
Return to the blank conversation in your chat model.
Paste the brief into the message field with Cmd+V (macOS) or Ctrl+V (Windows).

You should see the complete brief in the message field. All three source sections should appear before you send anything.

You now have the full source set queued in one message.

Write a question that needs every source

A useful cross-source prompt gives every source a clear role. It asks the model to connect context from the web page with evidence from the PDF.

The question also asks a podcast episode to support or challenge the emerging conclusion.

Place your cursor after the pasted brief.
Start a new line for your question.
Write a question about your chosen topic that requires context from the web page.
Add a requirement to compare that context with evidence from the PDF.
Add a requirement to use at least one podcast episode as support or a counterpoint.
Ask for a citation beside every source-backed claim.

Your draft should now contain the complete brief followed by one cross-source question. The citation requirement makes each source's contribution visible.

Verify the cross-source answer

The answer proves the brief is useful when its reasoning points back to all three source types. This final check looks for traceable evidence across the response.

Before you send the message, which source do you expect to contribute the most distinct evidence?

Send the complete message using the chat model's send control.

You should see a synthesized answer with source references beside its claims. The references should cover all three source types.

Scan the answer for a reference to the web page.
Locate a reference to the PDF.
Find the title of at least one returned podcast episode.
Compare the cited claims with the matching sections in brief.md.

That closes the research loop. You have proved that one brief can support an answer grounded in every source type.

Missing one of the sources?

Rewrite the question so the missing source must supply a specific piece of evidence.
Ask the model to revise the answer with a citation from the missing source.
Check the pasted brief for the section that contains the missing source.

Help me strengthen my cross-source question.

Secret mission

Audit the Answer's Evidence

Your brief brought three source types together. Now audit whether the final answer earns every citation. Trace one claim to the web page. Repeat the check for the PDF. Finish with the podcast evidence.

Clean Up Your Resources

Nothing from this project keeps running automatically after the script finishes. Future Firecrawl requests can still consume credits from your free account.

Resources you used:

Firecrawl API key copied from the dashboard.
Local research files named research-brief.js and brief.md.

Keep everything running

No action is needed. Choose this if you want to reuse the brief builder for another research topic.

Keeping the key is safe while it remains in the secure place you used earlier.

Return to the Firecrawl credit usage page from earlier.
Compare the current credit balance with the starting balance you noted.
Keep the API key in the secure place from earlier.
Keep research-brief.js and brief.md in their current folder.

The difference between the two balances shows the credits consumed during the project. Your account uses no more credits until you send another request.

Pause - I'll come back to this later

The script has finished. No process needs to be stopped while you take a break.

Return to the Firecrawl credit usage page from earlier.
Compare the current credit balance with the starting balance you noted.
Avoid running research-brief.js until you are ready to continue.
Leave research-brief.js and brief.md in their current folder.
Keep the API key in the secure place from earlier.

The balance comparison shows the credits already consumed. Pausing future requests prevents additional credit use.

Delete - I don't want to use this again

Revoking the key sounds final. Your generated brief stays readable until you delete the local files.

This option revokes the copied API key. It also removes the reusable script and generated brief.

Return to the Firecrawl credit usage page from earlier.
Compare the current credit balance with the starting balance you noted.
Return to the Firecrawl dashboard page where you copied the API key earlier.
Locate the copied key in the key list.
Use the delete control beside that key.
Confirm the key no longer appears in the list.

The deleted key can no longer authorize requests from research-brief.js.

The final cleanup removes the two local files through the code editor you used earlier.

macOS

Switch back to the code editor from earlier.
Select research-brief.js in the file sidebar.
Hold Cmd while selecting brief.md.
Right-click one of the selected files.
Choose the delete option from the context menu.
Confirm research-brief.js and brief.md no longer appear in the file sidebar.

Windows

Switch back to the code editor from earlier.
Select research-brief.js in the file sidebar.
Hold Ctrl while selecting brief.md.
Right-click one of the selected files.
Choose the delete option from the context menu.
Confirm research-brief.js and brief.md no longer appear in the file sidebar.

Your Firecrawl account stays active. The Particle provider terms remain accepted for the organization.

Nice Work!

You made it! You built a reusable research workflow that uses Firecrawl to turn three different source types into one brief for an AI agent.

What you learned:

Used Firecrawl's scrape endpoint to extract readable markdown from a web page. Reused the same endpoint to extract text from a PDF.
Searched the Alexandria podcast provider for relevant episodes. Reviewed the returned JSON results in your terminal.
Built a Node.js research workflow in research-brief.js. Generated brief.md with material from all three sources. Used the finished brief to get a cross-source answer with citations.
Secret Mission: extended your reusable brief builder through an optional challenge.

Ready to quiz yourself?