# Plant Talk: an OpenAI API example that gives a houseplant a camera, sensors and a voice

> Plant Talk is an Apache-2.0 example from OpenAI that turns a webcam, an optional Arduino soil and light sensor, and the Realtime voice conversation into a houseplant you can talk to. It is a build project first and a plant monitor second, and without the Arduino the readings are camera-only and much less accurate.

**openai/planttalk** — Give your houseplants a voice with ChatGPT.

- Repository: https://github.com/openai/planttalk
- Stars: 308 · Forks: 33
- Language: TypeScript
- License: Apache-2.0
- Published: 2026-09-18 · Updated: 2026-09-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/openai-planttalk

## What Plant Talk builds, and who it is for

Plant Talk is an OpenAI API example that ends in a houseplant you can hold a conversation with. It is published under the openai organisation, the README frames it as an educational build rather than a product, and the package description in the repository calls it an educational OpenAI API example. A laptop with a webcam and a microphone is enough to start. The optional second half of the build adds an Arduino-compatible microcontroller with a capacitive soil moisture sensor and an LM393 light sensor module. The stated audience is people who want to build something with hardware and the OpenAI API, and the README explicitly invites adaptation for a home, classroom, lab or art project. That framing sets the expectation correctly: this is a build guide with code attached, not a supported plant care product.

## The hardware list and what the Arduino buys you

The parts list is one of each: a laptop or desktop computer, Google Chrome or Edge, a webcam, a microphone and speakers, and a houseplant of your choosing, with built-in webcam and microphone explicitly allowed. The sensing half adds an Arduino-compatible microcontroller with a USB cable, a capacitive soil moisture sensor, an LM393 light sensor module, jumper wires and a small prototyping breadboard. The trade-off is stated plainly: the system works without the Arduino, but it then uses just the camera to understand plant health and is much less accurate. The microcontroller is therefore not decoration, it is the difference between a camera guess and an actual moisture reading. You also need the Codex Desktop app installed, a reliable Wi-Fi connection, and an OpenAI account, which you already have if you use ChatGPT.

## How a conversation gets its facts

The loop described in the README runs one way for sensing and the other way for talking. You open the dashboard, take an observation, and the current camera frame is sent for a structured plant check. With an Arduino connected, the app reads live soil moisture and light over USB serial. The Realtime voice conversation then works from those observations, and the README says the system can take live sensor readings, summarize recent observations and talk about what the plant needs. Five controls cover the surface: Start camera selects the webcam used for observations, Observe now sends the current camera frame, Connect Arduino reads the sensors, Talk to plant starts the Realtime conversation, and Open ambient mode switches to a full screen conversation view. The repository layout matches that split, with index.html and src/ for the dashboard, server/ for the API side, scripts/ for setup and arduino/ for the microcontroller side.

## Installing it the way the README tells you to

The README does not give a conventional setup sequence. It asks you to open Codex Desktop before wiring anything and type a single request, Help me make Plant Talk followed by the repository URL. Codex then reads the repository, including its AGENTS.md, and walks you through the build from the first setup step. If you would rather drive it yourself, the package.json gives the script names, and it requires Node 20.12 or newer.

```bash
npm install
npm run setup
```

The setup script is node scripts/setup.mjs. The .env.example file states that Codex setup copies it to .env, warns against pasting your API key into a chat, and points at platform.openai.com/api-keys. The only variable in it is OPENAI_API_KEY, set to replace-me.

```bash
npm run dev
```

That script runs the web and API sides together through concurrently, with vite dev for the front end and tsx watch on server/index.ts for the API. The repository also defines build as vite build and start as tsx server/index.ts for a run without the watcher. The README does not document which local port the dev server binds, so expect to read it from the Vite output.

## Ambient mode and the four knobs you can turn

Most users are told to leave the system in Ambient Mode when in use, which is the full screen conversation view. Once the basics work, the README describes the result as a small programmable plant interface and lists four starter customization points. Name changes the name the voice assistant uses. Personality tunes how the plant speaks and what it cares about. Voice swaps the spoken voice used in conversation. Observation changes what the camera analysis pays attention to. It also suggests asking Codex for a watering reminder, support for a different sensor, different ambient mode visuals, a new plant persona, long-term plant health logging, or an adaptation for a classroom demo.

## Where it falls short

The accuracy caveat is the first limitation: without the Arduino, the plant check is camera-only and, in the README's words, much less accurate. The browser requirement is the second, since Plant Talk uses some technology not supported by all browsers, and Chrome and Edge support it most reliably. The third is the Codex Desktop dependency, which the README lists alongside the OpenAI account as a prerequisite, so the documented path does not start from a plain terminal. On top of that this is version 0.1.0, marked private in package.json, with no published releases, and the last push was on 2026-06-30, so anything you build from it is yours to keep up to date.

## If you only want the numbers, use a sensor logger

If what you actually want is plant data, a capacitive probe wired to an ESPHome device and read in Home Assistant gives you continuous logging, thresholds and history charts from the same kind of sensor, and it never sends an image anywhere. What it will not do is look at the plant or answer a spoken question. Plant Talk takes the opposite position: the language model is the interface, and the camera and sensors exist to give it something true to say. The choice follows from which half you want. A moisture graph over six months is a logging job. A thing in your house that answers when you ask how it is doing is what this repo builds.

## Licence and dependencies

Plant Talk is Apache-2.0, with both a LICENSE and a NOTICE file in the repository, so the notice requirements that come with Apache-2.0 apply to anything you redistribute. The dependency list is short and current: react 19.2.4 with react-dom, express ^5.1.0 on the server side, the openai SDK at ^6.34.0, zod for validation, zustand for state and @picocss/pico for styling. Two entries are worth noticing, ogl, a small WebGL library, and idb-keyval for browser storage, although the README does not document what either is used for. Development uses Vite 8, TypeScript 5 and tsx, and the package requires Node 20.12 or newer.

## Conclusion

Build Plant Talk if you want an OpenAI API project that ends as something physical and you already have a webcam, Chrome or Edge and the Codex Desktop app. Skip it if you want accurate plant data, because the README states the camera-only path is much less accurate and the Arduino sensors are what make the readings useful. Check the parts list before you start, since the capacitive soil moisture sensor, the LM393 light module, the breadboard and the jumper wires are what decide whether the build is worth your evening.

## FAQ

### Does talking to plants actually work?

The README makes no claim that speech changes how a plant grows. What the project does is turn observations into conversation: the camera frame is sent for a structured plant check, an Arduino adds soil moisture and light over USB serial, and the voice conversation summarizes recent observations and talks about what the plant needs.

### Can plants hear people talk?

The README does not address plant hearing. The microphone here feeds the Realtime voice conversation, and the plant side of the data comes from the webcam and the optional sensors rather than from anything the plant perceives.

### Is it good to talk to my plants?

The README makes no horticultural claim either way. It frames the build as a small programmable plant interface, with name, personality, voice and observation as the four customization points, aimed at home, classroom, lab or art projects.

## Sources

- [Issues](https://github.com/openai/planttalk/issues)
- [License: Apache-2.0](https://github.com/openai/planttalk/blob/main/LICENSE)
- [openai/planttalk on GitHub](https://github.com/openai/planttalk)
- [README](https://github.com/openai/planttalk/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/openai-planttalk