Orca: a LinkedIn profile analysis agent that decides what to scrape next
AI agent for deep LinkedIn profile analysis.
At a glance
- What is it?
- Orca is a TypeScript and Next.js agent that scrapes a LinkedIn profile's posts, comments, reactions and interaction network, then reasons over the data to extract structured insights you define. Its core logic ships as a standalone library, but every run depends on a paid third-party scraping API.
- Who is it for?
- Adopt Orca if you already have a Fresh LinkedIn Profile Data subscription and want a self-hosted agent whose extraction logic you can embed in a Node.js pipeline under the MIT licence. Do not adopt it if you want a managed product, if you cannot accept that the app runs with no authentication unless Supabase credentials are set, or if you need structured insight types beyond the ones the agent already supports.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 50 days ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What Orca extracts, and who is asking for it
Orca takes a LinkedIn profile URL and a description of the insights you want, then returns those insights as structured output. The README lists the categories it targets: pain points, current focus, values, expertise, network influence, communication style, and how interests change over time. Three audiences are named explicitly. Sales teams use it to understand a prospect's priorities before outreach. Recruiters use it to assess what a candidate cares about beyond the résumé. Investors use it to map a founder's thinking and evaluate positioning. The common thread is that all three want signals a profile page states only indirectly. A résumé lists roles. Orca is aimed at the material around those roles: what the person posts about, which posts they comment on, and who reacts to them. That is a different extraction target than a keyword search over a headline, and it is the reason the project exists as an agent rather than a scraper plus a prompt.
The agent loop: baseline scrape, reason, call more tools
The README describes a four-step flow. You supply a profile URL and the insight definitions. Orca then scrapes a baseline set: profile, posts, comments, reactions, and top post engagement. The agent reasons over that baseline and produces structured insights. The distinguishing step is the third one: when the agent decides it needs more data for a specific insight, it calls additional scraping tools on its own. Results stream back to the UI as the agent works, so the interface reflects intermediate state rather than a single blocking response. The architecture has two visible layers. The Next.js 16 application provides the UI and the API route. The reasoning and extraction logic lives in orca-ai/, described in the README as a standalone library that you can plug into any Node.js project and run at scale. LangChain handles the model layer, with OpenAI as the default provider and Anthropic and other providers supported. The important consequence of that split is that the agent loop is not bound to the Next.js app. If you only want the extraction step inside an existing pipeline, orca-ai/ is the part to read first.
Installation and the two keys you cannot skip
The requirements list is short and specific: Node.js 20 or later, pnpm, a Fresh LinkedIn Profile Data API key from RapidAPI, and an API key for an LLM provider. The README shows the default as OpenAI. Setup is the standard clone and install sequence:
git clone https://github.com/dimimikadze/orca.git cd orca pnpm install pnpm dev
The app then serves on http://localhost:3000. Configuration goes in .env.local at the project root. Two variables are required:
RAPIDAPI_KEY=your_key OPENAI_API_KEY=your_key
Authentication is optional and off by default. Adding Supabase credentials turns it on:
NEXT_PUBLIC_SUPABASE_URL=your_url NEXT_PUBLIC_SUPABASE_ANON_KEY=your_anon_key
The README states that when those Supabase variables are set, all pages and the API are protected behind email and password login. Without them, the app runs open with no auth. That is a deliberate default for local use, and it is worth reading twice before exposing an instance anywhere reachable, because the API route is the same one the UI calls and it spends your RapidAPI quota.
The RapidAPI dependency is the real constraint
Orca does not scrape LinkedIn itself. Every piece of profile data arrives through the Fresh LinkedIn Profile Data API on RapidAPI. That single dependency shapes what the project can promise. The agent's autonomy is bounded by the tools available, and those tools are whatever that API exposes. If a data type is not reachable through it, the agent cannot fetch it no matter how the prompt is written. The second effect is cost and rate behaviour. The agent may call scraping tools repeatedly during a single analysis when it decides it needs more data, so per-profile API consumption is not fixed in advance. The README gives no figures for how many calls a typical run makes, and no release notes were retrieved, so there is no published basis for estimating it. Anyone planning batch runs should measure call counts on a sample before committing to a volume. The third effect is fragility. Any change on the API provider's side, in endpoint shape or in plan limits, lands directly on Orca, and there is nothing in the repository that can absorb it.
Tests run against recorded fixtures, not live profiles
The README states that all scrapers and the analysis agent are covered by tests, and that each test can run against recorded fixtures with no live API needed, or against real LinkedIn data by setting USE_LIVE_DATA = true in the test file. This is the most useful design decision documented in the repository. Fixture-based tests mean a contributor can work on the agent without a RapidAPI key and without spending quota, and CI can run deterministically. The live mode exists for validating that fixtures still match reality. The README points to package.json for the dedicated test cases and all available test commands, but does not enumerate them, so the exact commands have to be read from that file. The gap worth naming is fixture drift. Recorded responses are snapshots of a third-party API at a point in time. Nothing in the material describes a scheduled job that refreshes them, so the fixtures are only as current as the last person who ran the live mode.
Where Orca is the wrong tool
The open-by-default posture is the first boundary. With no Supabase variables set, the README says the app runs with no authentication and the API is unprotected. That is fine on a laptop. It is not fine on a public host, where an unauthenticated API route is an open door to someone else's RapidAPI bill. The second boundary is the dependency. If you want a system that owns its data collection, or you are unwilling to route profile data through a third-party API, Orca is the wrong starting point, because that path is not a configuration change. The third is scope. The insight categories listed in the README are the ones the project targets. If your extraction target is something else entirely, you are extending the agent, not configuring it. The fourth is legal and platform risk, which the README does not address at all. Scraping LinkedIn profile data through a third-party API carries terms-of-service and privacy exposure that varies by jurisdiction and by how the data is used. The material supplied here contains no guidance on this, and none should be inferred from it.
How it differs from a generic scraping plus LLM pipeline
The obvious alternative is assembling the same thing yourself: call a LinkedIn scraping API, dump the JSON into a prompt, and ask a model for a summary. The difference is in step three of Orca's flow. A single-pass pipeline commits to one fetch before it knows what the data looks like. Orca's agent inspects the baseline, decides that a particular insight is under-supported, and calls more scraping tools on its own. That makes the data collection conditional on the analysis rather than fixed in advance. The trade-off is real and runs the other way too: a single-pass pipeline has predictable cost and latency per profile, while an agent that decides its own fetch schedule does not. The second difference is packaging. Orca separates the agent into orca-ai/ as a library you can embed in any Node.js project, so you are not required to adopt Next.js 16 or the bundled UI to use the reasoning layer. A hand-rolled pipeline gives you full control over every prompt and every call, but you own the insight schema, the retry behaviour, and the tool-calling loop yourself. The choice is between a fixed pipeline you can reason about and an adaptive one whose per-run consumption you have to measure.
Licence, maintenance and what to check before adopting
Orca is distributed under the MIT License, with the full text in LICENSE. That permits commercial use, modification and redistribution provided the copyright notice and permission notice are retained. It does not cover the services Orca calls. Your RapidAPI subscription and your LLM provider's terms are separate agreements, and the MIT grant says nothing about them. On maintenance, the repository is not archived and the last push recorded is 2026-07-27. No releases were retrieved, so there is no versioned changelog to track and no tagged artefacts to pin against. Upgrades therefore mean tracking the main branch, and the practical cost of that is re-validating the fixture-based tests after each pull, plus re-checking that the RapidAPI endpoints the tools depend on still behave as the fixtures assume. The repository includes a CI workflow and a CONTRIBUTING.md, so the project has a stated contribution path, but the absence of releases means there is no notion of a stable version to depend on. Before adopting, run one profile through the full flow with your own keys, count the RapidAPI calls that single run consumes, and confirm that number against your plan's limits.
Editorial conclusion
Adopt Orca if you already have a Fresh LinkedIn Profile Data subscription and want a self-hosted agent whose extraction logic you can embed in a Node.js pipeline under the MIT licence. Do not adopt it if you want a managed product, if you cannot accept that the app runs with no authentication unless Supabase credentials are set, or if you need structured insight types beyond the ones the agent already supports. Verify first that your RapidAPI plan covers the volume of calls the autonomous tool-calling loop generates, and run a single profile end to end before pointing it at a batch.
Community notes