# Innovation Radar — Field Trends & Idea Validation (`tacps126/innovation-radar`) Actor

Analyse a technology field or validate a product idea from open research and patent data: growth and momentum, leading countries, institutions and funders, rising sub-topics, standout and closest work, related patents. Optional AI opportunities on your own key. $0.03 per analysis.

- **URL**: https://apify.com/tacps126/innovation-radar.md
- **Developed by:** [Tapaswai Ashok Choudhary](https://apify.com/tacps126) (community)
- **Categories:** AI, Business, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $24.00 / 1,000 analyses

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Innovation Radar — Field Trends & Idea Validation

Point it at a **technology field** or describe a **product idea**, and get an analysis instead of a pile of links:

- **Field landscape** — how much is published per year, how fast it is growing (and whether it's speeding up or cooling down), which countries, institutions and funders lead it, which sub-topics are rising, the standout recent work, and related patents.
- **Idea validation** — how many works already cover the idea, how many in the last two years, whether the space is open, early, active or crowded, the biggest neighbouring space (so a niche inside a crowded field is called out), who is working on it, the closest prior work, and related patents.
- **Scores you can compare** — an **opportunity score** (0–100) with the reasons behind it, plus **momentum**, **lab-to-market gap** (research racing ahead of products) and **geographic concentration**. Analyse several fields in one run and they come back ranked.
- **Who is in it** — industry participation (share of recent work with a company author, and whether companies are moving in or out), the **top companies**, key researchers, institutions and funders: partners, hires, licensors and competitors.
- **Opportunities (optional AI)** — product ideas with *why now*, a capital bucket (under $50k / $50k–$1M / over $1M) with the reasoning, who to talk to, risks and next steps. Use Apify's built-in AI (no key, billed to your Apify account) or your own Anthropic, OpenAI, Gemini, OpenRouter, Groq, Mistral, DeepSeek or local model.

Every run also saves a readable **report** (Markdown) and an **AI brief**: the analyst rubric plus the run's evidence, ready to paste into any assistant you already use.

**Built for** founders looking for what to build, R\&D and innovation teams scouting a technology, investors and consultants sizing a field, IP professionals, and AI agents that need a quick read on a domain.

### How to use it

**Landscape:** choose *Analyse fields*, enter one or more fields (`solid state battery`, `CRISPR base editing`, `retrieval augmented generation`), press **Start**.

**Validation:** choose *Validate ideas*, describe each idea in a sentence (`a window that generates solar power with perovskite tandem cells`), press **Start**.

Turn on **AI insight** for opportunities and an assessment written for you. *Apify (no key)* runs the model through Apify's AI gateway, billed to your Apify account; with your own key you pay your provider directly. The Actor charges nothing extra for AI either way.

```json
{
  "mode": "landscape",
  "fields": ["solid state battery", "sodium-ion battery"],
  "years": 10
}
```

### Output

**Landscape record:** `field`, `rank` (when several fields), `scores` ({opportunity, momentum, labToMarketGap, geographicConcentration, why}), `industry` ({recentShare, trend}), `topCompanies`, `keyResearchers`, `reviewShare`, `worksPerYear` (\[{year, works}]), `growth` ({cagrPercent, lastTwoYearsVsPreviousTwoPercent, stage}), `topCountries`, `topInstitutions`, `topFunders`, `topTopics`, `risingTopics` ({topic, recentWorks, shareLift}), `standoutRecentWorks` (title, venue, date, citations, first author, institution, link), `relatedPatents` (number, title, applicants, filing date, `likelyExpiredByTerm`), `insight` (with an AI key).

**Validation record:** `idea`, `searchedFor`, `matchingWorks`, `worksLastTwoYears`, `crowdedness`, `broaderSpace` and `position` (e.g. *open niche in a crowded field*: the application is new, the base technology is busy), `growth`, `worksPerYear`, `closestWorks`, `whoIsWorkingOnIt` (researchers, institutions, companies), `relatedPatents`, `insight` (novelty, closest prior work, feasible now because…, capital, risks, next steps).

The key-value store holds `REPORT` — the same results as a document you can read or share — and `AI_BRIEF`.

### Example: three battery chemistries, one run

`fields: ["sodium-ion battery", "solid state battery", "perovskite solar cell"]` ranked sodium-ion first (opportunity 79: fast growth, a wide lab-to-market gap, companies such as CATL and Faradion moving in), solid-state second (62) and perovskite third (46). Each score lists the signals behind it.

### Use your own AI, or none

The analysis — counts, trends, scores, companies — needs no AI at all. For the written part you have three options:

1. **AI insight in the Actor** — Apify (no key) or any supported provider on your key.
2. **`AI_BRIEF`** — paste it into ChatGPT, Gemini, Claude, Copilot or a local model. Every model gets the same rubric and answer shape, so results stay comparable.
3. **From an AI agent** — the [webdata-tools MCP server](https://github.com/tacps126/webdata-tools-mcp) exposes `analyze_field` and `validate_idea` plus ready-made *field-opportunity-analysis* and *idea-validation* prompts for Claude Desktop, Cursor and other MCP clients.

### Data

Scholarly data from **OpenAlex** (250M+ works, CC0) and patent records from **Europe PMC**. Coming next: free-to-use patents (expired, or lapsed early because fees weren't paid) and patent filing trends from the USPTO and EPO.

### Pricing

**$0.03 per analysis** (one field or one idea) plus a small start fee per run. AI insight is billed by Apify's AI gateway or your own provider at their prices. A free [OpenAlex key](https://openalex.org/settings/api) is recommended for frequent runs.

### Good to know

Trends reflect published research, which leads products by years. Patent notes are not legal advice: an expired patent can have related patents still in force — check before building. AI notes are estimates.

# Actor input Schema

## `mode` (type: `string`):

Landscape: size, growth, leaders, funders and rising topics of a field. Validate: how new or crowded an idea is, and the closest prior work.

## `fields` (type: `array`):

For landscapes, e.g. `solid state battery`, `CRISPR base editing`, `retrieval augmented generation`. Multi-word fields are searched as a phrase.

## `ideas` (type: `array`):

For validation, in plain words, e.g. `a window that generates solar power with perovskite tandem cells`.

## `years` (type: `integer`):

How far back the trend goes.

## `topWorks` (type: `integer`):

Standout recent works (landscape) or closest works (validation).

## `aiInsight` (type: `boolean`):

Add opportunities (what to build, for whom, why now, capital needed, who to talk to) or an idea assessment, written by the AI below. Without it you still get every score and signal, plus an AI_BRIEF you can paste into any assistant.

## `aiProvider` (type: `string`):

Which AI does the analysis. Apify needs no key: the model runs through Apify's OpenRouter proxy and is billed to your Apify account. Any other provider uses your own key and bills you there.

## `aiApiKey` (type: `string`):

Your own key for the provider above (not needed for Apify). Sent only to that provider, never stored.

## `aiModel` (type: `string`):

Model name. Apify: an OpenRouter id like anthropic/claude-sonnet-… or google/gemini-… (default: the newest Claude Sonnet listed). Anthropic: default claude-opus-5-5. Others: required.

## `aiBaseUrl` (type: `string`):

Only for "Other OpenAI-compatible API", e.g. http://localhost:11434/v1 for Ollama.

## `insightLanguage` (type: `string`):

Language of the AI insight. Default English.

## `openalexApiKey` (type: `string`):

A free key from openalex.org/settings/api gives your runs their own daily budget (each analysis makes about 7 OpenAlex requests).

## Actor input object example

```json
{
  "mode": "landscape",
  "fields": [
    "solid state battery"
  ],
  "years": 10,
  "topWorks": 10,
  "aiInsight": false,
  "aiProvider": "apify"
}
```

# Actor output Schema

## `results` (type: `string`):

The produced items (default dataset items).

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "fields": [
        "solid state battery"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tacps126/innovation-radar").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "fields": ["solid state battery"] }

# Run the Actor and wait for it to finish
run = client.actor("tacps126/innovation-radar").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "fields": [
    "solid state battery"
  ]
}' |
apify call tacps126/innovation-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tacps126/innovation-radar"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/JLzItYtqtOhZO6QLr/builds/bhTqfw9YyL6d8LOWL/openapi.json