Plant Care Guide Creation from Species Photos and Research

Creating plant care guides manually is tedious work. You need to identify the species from a photo, research its specific care requirements, summarise that research into readable text, and then format everything into a presentable document. Most people do this across five or six different browser tabs, copying and pasting between applications, fixing formatting issues, and hoping nothing gets lost in the handoff.

What if you could upload a photo of a plant and have a complete, formatted care guide appear in your inbox thirty minutes later? The workflow already exists; it just requires connecting four specialist tools through an orchestration platform. No coding knowledge needed. No manual data transfer. Just input, processing, and output.

This Alchemy demonstrates how to combine plant identification, research summarisation, and document creation into a single automated workflow. We'll use PlantPhotoAI to identify the species, Resoomer to summarise care articles, Preswald to generate the guide content, and Widify to create a shareable document format. The whole thing runs on a schedule or triggers from a webhook.......... For more on this, see Automated legal document review and client summary genera....

The Automated Workflow

The Overall Data Flow

The workflow operates like this: a trigger (either a scheduled time or an API call) starts the process. A plant photo gets uploaded to PlantPhotoAI, which returns species information. That species name feeds into a web search or API call that retrieves care articles. Those articles get summarised by Resoomer. The summarised text, combined with the species name and identification confidence, goes into Preswald to generate structured content. Finally, Widify formats the entire guide as a shareable PDF or webpage. The finished document gets stored or emailed.

This works best with Make or n8n because both platforms handle sequential API calls with data mapping easily. Zapier works but requires more conditional logic workarounds. Claude Code works if you prefer a Python-based approach with more control over each step.

Setting Up With Make

Make (formerly Integromat) is the most straightforward option for this workflow. Here's how to structure it.

Start by creating a new scenario in Make. Add an HTTP trigger or a Schedule trigger if you want this to run at specific times each day.

Copy
Trigger: Webhook (Custom)
Method: POST
Expected Format:
{
  "photo_url": "https://example.com/plant.jpg",
  "email": "user@example.com"
}

Connect your first module to PlantPhotoAI. Most plant identification APIs accept either image URLs or base64 encoded data. PlantPhotoAI's endpoint looks like this:

Copy
POST https://api.plantphotoai.com/v1/identify
Headers:
  Authorization: Bearer YOUR_API_KEY
  Content-Type: application/json

Body:
{
  "image_url": "{{ trigger.photo_url }}",
  "include_care_tips": true
}

Make will parse the response automatically. You'll get back something like:

Copy{
  "results": [
    {
      "species": "Monstera deliciosa",
      "common_name": "Swiss Cheese Plant",
      "confidence": 0.94,
      "family": "Araceae"
    }
  ]
}

Map the species name from this response into your next module. Add an HTTP request to search for care articles. You could use a generic search API or feed the species directly into your browser's knowledge base. For this example, we'll construct a simple search request:

Copy
GET https://api.example-botanical-database.com/search
Query Parameters:
  q: "{{ step1.results[0].species }} care guide"
  limit: 5

Response:
[
  {
    "url": "https://...",
    "title": "Monstera deliciosa Care Guide",
    "content": "Water when soil is 50% dry..."
  }
]

Now add a Resoomer module. Resoomer summarises text or URLs efficiently. Configure it to take the article content from step 2:

Copy
POST https://api.resoomer.com/v1/summarize
Headers:
  Authorization: Bearer YOUR_RESOOMER_API_KEY
  Content-Type: application/json

Body:
{
  "text": "{{ step2[0].content }}",
  "summary_type": "short",
  "sentences": 8
}

Response:
{
  "summary": "Monstera deliciosa thrives in bright indirect light..."
}

Next, use Preswald to generate structured guide content. Preswald takes structured data and turns it into formatted content blocks:

Copy
POST https://api.preswald.com/v1/generate
Headers:
  Authorization: Bearer YOUR_PRESWALD_API_KEY
  Content-Type: application/json

Body:
{
  "template": "plant_care_guide",
  "data": {
    "species_name": "{{ step1.results[0].species }}",
    "common_name": "{{ step1.results[0].common_name }}",
    "confidence": "{{ step1.results[0].confidence }}",
    "care_summary": "{{ step3.summary }}",
    "identification_family": "{{ step1.results[0].family }}"
  }
}

Response:
{
  "content": {
    "title": "Monstera deliciosa Care Guide",
    "sections": [
      {
        "heading": "About This Plant",
        "body": "..."
      }
    ],
    "html": "<html>...</html>"
  }
}

Finally, pass the generated content to Widify to create a shareable format. Widify can convert HTML into a formatted document or webpage:

Copy
POST https://api.widify.com/v1/create
Headers:
  Authorization: Bearer YOUR_WIDIFY_API_KEY
  Content-Type: application/json

Body:
{
  "html": "{{ step4.content.html }}",
  "output_format": "pdf",
  "filename": "{{ step1.results[0].species }}_care_guide.pdf",
  "metadata": {
    "title": "{{ step4.content.title }}",
    "created_at": "{{ now }}",
    "identified_confidence": "{{ step1.results[0].confidence }}"
  }
}

Response:
{
  "document_url": "https://widify-output.example.com/...",
  "file_id": "abc123def456"
}

Add a final email module to send the completed guide to the user:

Copy
Send email to: {{ trigger.email }}
Subject: Your {{ step1.results[0].species }} Care Guide is Ready
Body: See attached document or click here: {{ step5.document_url }}
Attachment: {{ step5.file_id }}

The entire flow now runs without manual intervention. Upload a photo, receive a complete guide.

Alternative: Using n8n

n8n handles this similarly but gives you more visibility into data transformation. The workflow structure is identical, but n8n's node-based editor makes it easier to see where data is being mapped. Set up HTTP Request nodes for each API call and use Function nodes to transform data between steps if needed:

Copy// Example Function node to extract the species name
return {
  species: data[0].results[0].species,
  confidence: data[0].results[0].confidence,
  common_name: data[0].results[0].common_name
};

This function sits between the PlantPhotoAI node and the search node, ensuring clean data flow.

Using Claude Code for More Control

If you prefer a Python-based approach, Claude Code lets you write the entire workflow in one place:

Copyimport requests
import json
from datetime import datetime

PLANT_PHOTO_API_KEY = "your_api_key"
RESOOMER_API_KEY = "your_api_key"
PRESWALD_API_KEY = "your_api_key"
WIDIFY_API_KEY = "your_api_key"

def identify_plant(image_url):
    """Call PlantPhotoAI to identify the plant species"""
    response = requests.post(
        "https://api.plantphotoai.com/v1/identify",
        headers={"Authorization": f"Bearer {PLANT_PHOTO_API_KEY}"},
        json={"image_url": image_url, "include_care_tips": True}
    )
    return response.json()["results"][0]

def search_care_articles(species_name):
    """Search for care articles about the identified species"""
    response = requests.get(
        "https://api.example-botanical-database.com/search",
        params={"q": f"{species_name} care guide", "limit": 5}
    )
    return response.json()[0]

def summarise_article(content):
    """Summarise the article using Resoomer"""
    response = requests.post(
        "https://api.resoomer.com/v1/summarize",
        headers={"Authorization": f"Bearer {RESOOMER_API_KEY}"},
        json={"text": content, "summary_type": "short", "sentences": 8}
    )
    return response.json()["summary"]

def generate_guide(plant_data, summary):
    """Generate structured guide content with Preswald"""
    response = requests.post(
        "https://api.preswald.com/v1/generate",
        headers={"Authorization": f"Bearer {PRESWALD_API_KEY}"},
        json={
            "template": "plant_care_guide",
            "data": {
                "species_name": plant_data["species"],
                "common_name": plant_data["common_name"],
                "confidence": plant_data["confidence"],
                "care_summary": summary,
                "identification_family": plant_data["family"]
            }
        }
    )
    return response.json()["content"]

def create_document(html_content, species_name):
    """Convert to shareable format using Widify"""
    response = requests.post(
        "https://api.widify.com/v1/create",
        headers={"Authorization": f"Bearer {WIDIFY_API_KEY}"},
        json={
            "html": html_content,
            "output_format": "pdf",
            "filename": f"{species_name}_care_guide.pdf"
        }
    )
    return response.json()["document_url"]

def send_email(recipient, document_url, species_name):
    """Send the completed guide to the user"""
    # Use your email service here (SendGrid, AWS SES, etc.)
    print(f"Email sent to {recipient}: {document_url}")

# Main workflow
def create_plant_guide(image_url, email):
    print("Step 1: Identifying plant...")
    plant = identify_plant(image_url)
    
    print("Step 2: Searching for care articles...")
    article = search_care_articles(plant["species"])
    
    print("Step 3: Summarising article...")
    summary = summarise_article(article["content"])
    
    print("Step 4: Generating guide...")
    guide = generate_guide(plant, summary)
    
    print("Step 5: Creating document...")
    doc_url = create_document(guide["html"], plant["species"])
    
    print("Step 6: Sending email...")
    send_email(email, doc_url, plant["species"])
    
    return {"status": "success", "document_url": doc_url}

# Example usage
if __name__ == "__main__":
    result = create_plant_guide(
        image_url="https://example.com/monstera.jpg",
        email="user@example.com"
    )
    print(json.dumps(result, indent=2))

This approach gives you complete control over error handling, retry logic, and data validation. You can run it locally, schedule it with cron, or deploy it to a serverless function.

The Manual Alternative

If you prefer not to automate, the process is straightforward but time consuming. Upload your plant photo to PlantPhotoAI's web interface and note the species name. Search Google Scholar or a botanical database for care articles about that species. Read through the articles and manually highlight the key care requirements. Copy the summarised information into Preswald and generate the guide structure. Take the HTML output and run it through Widify to create a PDF. Finally, email the document to yourself or whoever needs it.

This approach takes approximately 20 to 40 minutes per plant, depending on how thorough you want the research to be. The automated workflow completes the same task in under five minutes, and once you set it up, it requires zero active work.

Pro Tips

Handle Rate Limiting Gracefully. Most API providers implement rate limits. PlantPhotoAI typically allows 100 requests per hour on free plans. Add delay modules between API calls in Make or n8n to avoid hitting these limits if you're processing multiple plants quickly. In the Claude Code example, add exponential backoff logic:

Copyimport time

def call_with_retry(url, headers, json_data, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.post(url, headers=headers, json=json_data)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.HTTPError as e:
            if e.response.status_code == 429:  # Rate limit error
                wait_time = 2 ** attempt
                print(f"Rate limited. Waiting {wait_time} seconds...")
                time.sleep(wait_time)
            else:
                raise

Validate Image Quality Before Processing. Not every photo will produce a confident plant identification. Set a minimum confidence threshold in your workflow. If PlantPhotoAI returns a confidence score below 0.80, skip the rest of the workflow and email the user asking for a clearer photo. This saves API costs on low-quality identifications.

Cache Research Results. If you're processing multiple photos of the same species, you're fetching and summarising the same care articles repeatedly. Store the summarised content in a simple database keyed by species name. Before calling Resoomer, check whether you already have a summary for this species. This approach reduces API costs significantly if you're building a library of common houseplants.

Monitor for API Changes. API endpoints and response formats change occasionally. Set up basic error logging in your workflow. If an API call fails, log the full request and response. Review these logs weekly. Most failures indicate that an endpoint URL has changed or the response structure has shifted, both of which are easy to fix once you know about them.

Test With Common Species First. When setting up the workflow, start with well documented plants like Monstera deliciosa or Pothos. These have abundant care information online and high identification confidence scores. Once the workflow runs smoothly with common species, expand to more obscure plants.

Cost Breakdown

If you process 20 plant photos per month, your total cost is roughly £35 to £50, or approximately £1.75 to £2.50 per guide. Processing manually would cost your time instead, equivalent to 6 to 13 hours of work depending on your hourly rate.