# Plant Health Analyzer (`saadithya/plant-health-analyzer`) Actor

Plant Health Analyzer uses AI vision to analyze plant images and detect signs of stress, disease, or nutrient issues. It provides easy-to-understand health insights and care suggestions to help plants grow healthier. For informational purposes only.

- **URL**: https://apify.com/saadithya/plant-health-analyzer.md
- **Developed by:** [Aadhithya](https://apify.com/saadithya) (community)
- **Categories:** AI, Agents
- **Stats:** 10 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🌱 Plant Health Analyzer

An AI-powered plant disease detector that analyzes plant images to identify health issues, provide diagnoses, and suggest appropriate treatments. The actor uses computer vision and plant pathology knowledge to examine plant symptoms and offer actionable recommendations for plant care.

### Overview

The Plant Health Analyzer leverages advanced AI vision models to examine plant images and identify potential health issues, diseases, or nutrient deficiencies. It analyzes visual symptoms such as discoloration, spots, wilting, and other plant abnormalities, then provides professional diagnoses and treatment recommendations.

### How It Works

1. **Provide Plant Image**: Supply a clear image of a plant showing symptoms via URL
2. **Ask Questions (Optional)**: Include specific questions about plant issues or care
3. **AI Analysis**: The system examines visible plant symptoms using computer vision
4. **Professional Diagnosis**: Plant pathology analysis identifies potential issues
5. **Treatment Recommendations**: Receive actionable care suggestions and solutions

### Input Parameters

The actor accepts the following input:

- `imageUrl`: Public URL of the plant image to analyze (required)
- `question`: Optional specific question about the plant issue or care instructions
- `openaiApiKey`: Your OpenAI API key (optional, will use platform secrets if not provided)
- `model`: Vision-capable model (e.g. 'gpt-4o-mini', 'gpt-4o')
- `testMode`: Enable test mode for auto-testing with sample data (defaults to false)

*Note: Either `imageUrl` or `imageKey` is required*

### Output

The actor returns a comprehensive plant health analysis including:

- `plantIssues`: Object containing descriptions of identified plant problems
  - `symptoms`: Description of visible symptoms and their locations
  - `severity`: Assessment of issue severity (mild, moderate, severe)
  - `affectedAreas`: Which parts of the plant are affected
- `diagnosis`: Professional assessment of potential diseases or conditions
- `treatment`: Recommended treatment options and care instructions
- `prevention`: Tips to prevent similar issues in the future
- `questionAnswer`: Specific answer to user's question (if provided)

### Example Use Cases

- Diagnosing plant diseases and health issues
- Identifying nutrient deficiencies
- Getting treatment recommendations for sick plants
- Learning proper plant care techniques
- Preventing plant problems before they worsen
- Garden and farming advisory support

### Quick Start

1. Capture a clear photo of your plant showing symptoms (ensure good lighting and focus)
2. Make the image publicly accessible via URL
3. Provide your OpenAI API key (as input or platform secret)
4. Run the actor with your plant image URL
5. Receive professional plant health analysis and treatment recommendations

### Sample Input

```json
{
  "imageUrl": "https://example.com/my-plant-photo.jpg",
  "question": "What's wrong with my tomato plant leaves?",
  "openaiApiKey": "your-openai-api-key-here",
  "model": "gpt-4o-mini",
  "testMode": false
}
```

### Sample Output

```json
{
  "plantIssues": {
    "symptoms": "Yellowing leaves with brown spots, wilting lower leaves",
    "severity": "moderate",
    "affectedAreas": "leaves, stem base"
  },
  "diagnosis": "Likely fungal infection (early blight) combined with possible nutrient deficiency",
  "treatment": "1. Remove affected leaves immediately. 2. Apply fungicide spray weekly. 3. Improve soil drainage. 4. Add balanced fertilizer.",
  "prevention": "Ensure proper spacing, water at base not leaves, rotate crops annually, maintain soil health",
  "questionAnswer": "The yellowing with brown spots on lower leaves indicates early blight fungus. Remove affected parts and treat with copper-based fungicide."
}
```

### Benefits

- **Visual Plant Analysis**: Uses AI vision models to identify plant health issues accurately
- **Professional Diagnosis**: Provides expert-level plant pathology assessments
- **Actionable Treatment**: Offers specific, practical care recommendations
- **Preventive Guidance**: Helps prevent future plant health problems
- **Question Support**: Answers specific user questions about plant care
- **Easy to Use**: Requires only a plant image URL and optional API key
- **Scientific Approach**: Based on established plant pathology principles

### Safety & Compliance

⚠️ **Important Safety Features**:

- **Educational Purpose**: Designed for plant care education and guidance
- **Professional Recommendations**: Based on established horticultural practices
- **Non-Medical**: Does not replace professional agricultural consultation
- **General Guidance**: Provides general care advice, not specific medical treatment
- **Clear Limitations**: Acknowledges when professional help is needed
- **Responsible Advice**: Recommends consulting experts for serious issues

### Responsible AI Usage

This actor follows responsible AI practices by:

1. **Clear Positioning**: Explicitly plant care-focused
2. **Professional Standards**: Follows established horticultural practices
3. **Transparent Limitations**: Acknowledges when expert consultation is needed
4. **User Protection**: Prevents potentially harmful plant treatments
5. **Educational Aspect**: Promotes proper plant care knowledge

### Monetization

The actor can be configured with pay-per-event pricing:

- Event name: `plant-analysis`
- Suggested price: $0.05 per successful analysis
- Triggered only when plant issues are successfully detected
- Configurable through Apify platform billing settings

### Important Disclaimer

**This AI-generated plant analysis is for educational and advisory purposes only. It does not replace professional agricultural or botanical consultation. Serious plant health issues should be evaluated by qualified horticulturists or plant pathologists.**

Plant care recommendations are based on general horticultural principles and may not address all specific conditions. Always research local conditions and consult experts for critical plant health decisions.

# Actor input Schema

## `testMode` (type: `boolean`):

Enable test mode for auto-testing with sample plant data (no imageUrl required)

## `imageUrl` (type: `string`):

Public URL of the plant image showing symptoms to analyze

## `question` (type: `string`):

Optional question about plant issues, care instructions, or specific concerns

## `openaiApiKey` (type: `string`):

Your OpenAI API key for plant analysis (will use platform secrets if not provided)

## `model` (type: `string`):

Vision-capable model for plant analysis

## Actor input object example

```json
{
  "testMode": true,
  "model": "gpt-4o-mini"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("saadithya/plant-health-analyzer").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("saadithya/plant-health-analyzer").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 '{}' |
apify call saadithya/plant-health-analyzer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,saadithya/plant-health-analyzer"
        }
    }
}

```

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/24y5bGUe9IRmw0cat/builds/PSc2Pj4ZBr5w5pRxa/openapi.json