Show us what you’re building with the ChatGPT Apps SDK 🚀

[coreyching]

Note: Public distribution for ChatGPT apps is coming later this year. This thread is not an official app submission or review flow. It’s an informal place to share what you’re building, get feedback, and swap ideas with other developers.

Hey everyone,

We’re excited to see what you’re building with the ChatGPT Apps SDK!

This thread is an early-interest hub for developers to:

• Share what you’ve built (or are building)

• Get feedback from the community and OpenAI folks

• Discover examples, patterns, and ideas from others

• Help shape what we prioritize next for the Apps SDK

---

How to share your app

When you post a reply, it’s helpful to include:

1. App name + one-liner
   Example: “Repo Radar – a ChatGPT app that lets you search and summarize issues across multiple GitHub repos.”

2. What it does
   Briefly describe the main use case and who it’s for.

3. How you built it

   • Are you using a 3rd party apis? Which tools/integrations?

   • What stack are you using (Node/Python, framework, hosting)?

   • Any interesting patterns (auth, multi-step flows, widgets, etc.)?

4. Screenshots or short video (optional but awesome)
   Visuals really help others understand what you’re doing.

5. Links

   • GitHub repo (if you’re comfortable sharing)

   • Live demo / deployment (if applicable)

---

Example format

You can copy-paste this and fill it in:

• App name:

• One-liner:

• Who it’s for / problem it solves:

• Key features:

• How it uses the Apps SDK / what UI you’re rendering in ChatGPT:

• Stack & tools:

• Link(s):

• Anything you’d love feedback on:

---

Early access + feedback

We’re especially interested in:

• What’s working well for you in the Apps SDK

• What’s confusing, rough, or missing

• Patterns you think other builders should know about

Your projects and feedback here will help guide how we evolve the Apps SDK and examples.

Looking forward to seeing what you’re building — drop your app below!

[Lakshya_Bakshi]

• App name: Heron Health

• One-liner: Patient Triage for low aquity Dermatology and other medical specialty care

• Who it’s for / problem it solves: Patients are using LLMs for medical triage on low aquity issues without professional oversight. Heron catches instances of medical triage, prepares a patient summary, and connects the user to local providers to give actual oversight.

• Key features: Management of health information related to dermatology, translation of queries to onboarding material for dermatology specialists, backend system automation for submitting patient inquiries into triage portal.

• How it uses the Apps SDK / what UI you’re rendering in ChatGPT: Rendering map view of providers + miniaturized auto-onboarding UI for any one of those providers.

• Stack & tools: NextJS, Supabase, and AWS

• Link(s): [pending]

• Anything you’d love feedback on: [pending]

[achieving100ms]

App Name:
Memories Video Editor - Empowering your favorite ChatGPT to craft family slideshows and tributes Tools for preserving memories

---

What it does:
The Memories Video Editor lets users (and their families) collaboratively create memorial and celebration videos - like tributes for a loved one - directly through ChatGPT.

It provides a secure, high-fidelity way to upload and manage real family assets (photos, videos, audio clips), preserving their original quality. Family members can upload through short-lived, shareable links, and GPT can then analyze the media, help storyboard the narrative, and instruct our rendering engine to produce the final video.

We focus on authentic storytelling, using real memories rather than AI-generated imagery, while still taking advantage of ChatGPT’s creative scripting and structuring capabilities.

---

How it’s built:

• Firestore for database and session state

• Google Cloud Functions for API / MCP / rendering pipeline

• Next.js for in-ChatGPT widgets UI (with some tweaks for proper SDK interop. happy to share tips!)

• TypeScript end-to-end

• Zod v4 for strict schema validation (APIs, webhooks)

• Vitest for automated testing

---

Interesting patterns:
The challenge is enabling agentic, multi-step workflows inside ChatGPT. A typical family slideshow involves:

1. Uploading 50+ assets (images, clips, audio) - often collected from multiple family members.

   • We provide secure, Dropbox-like upload links that preserve original quality.

2. Analyzing each asset (including video) to produce raw metadata and actual content descriptions.

3. Collaboratively building a visual storyboard with GPT - our widgets show thumbnails inline so the AI and user can iterate together.

4. Generating a full processing instruction set for the renderer, blending narrative, assets, and transitions into a final shareable tribute.

It’s a very human workflow - emotional, creative, multi-asset - and the Apps SDK has been a great foundation for bridging GPT’s intelligence with our backend.

---

Screenshots / Demo:
We build in public - posting weekly updates and demos on X Memories Video Editor

---

Feedback for the Apps SDK / ChatGPT Teams

Agentic Tool Discovery (Decision Framework)

We found a significant opportunity to improve how ChatGPT decides when to explore api_tool capabilities.

When a user says something like:

“I want to build a tribute video for my grandmother.”

ChatGPT typically assumes a text-based creative task and doesn’t explore domain tools - even though a specialized suite like Memories Video Editor exists.

Because users don’t know these tools exist, ChatGPT never discovers them unless explicitly instructed. This means even the most relevant, purpose-built SDK integrations go unused.

Suggested improvement:

• Add a lightweight auto-discovery step whenever a user’s request involves media, uploads, or creative assembly.

• ChatGPT could run api_tool.list_resources silently or semi-explicitly, then mention:

  “I found a tool that might help with this. Would you like to use it?”

This small change would unlock huge potential for multi-modal apps like ours and make new SDK tools discoverable without requiring insider knowledge.

We’ve been coaching people to say things like:

“Please explore your available tools (including api_tool) before choosing how to help.”

…but ideally, ChatGPT shouldn’t need prompting for that.

---

Structured Schema Propagation

Another minor but impactful gap: the SDK’s transformation from app-defined schemas → internal api_tool instructions currently loses output type fidelity.

Example:

'create_or_extend_upload_url',
{
  description: `Create a new upload URL or extend an existing one...`,
  inputSchema: {
    hoursToAdd: z.number().optional().default(24).describe('Hours to add to expiration'),
  },
  outputSchema: {
    url: z.string().describe('The upload URL that can be shared'),
    sessionId: z.string().describe('The upload session ID'),
    expiresAt: z.string().describe('ISO 8601 timestamp of when the URL expires'),
  },
}

gets transformed to:

// Create a new upload URL or extend an existing one...
type /Memories Video Editor/.../create_or_extend_upload_url = (_: {
// Hours to add to the expiration
hoursToAdd?: number, // default: 24
}) => any;

The outputSchema is well-defined, but the api_tool type still renders the return as any.

Suggestion: propagate outputSchema types just like inputSchema.
This would preserve type safety, improve SDK-generated docs, and reduce manual duplication in tool descriptions.

[bmc]

App name:

AskMyMoney

One-liner:

A ChatGPT-native personal finance assistant that connects to your bank via Plaid and lets you manage your money using pure natural language.

---

Who it’s for / problem it solves:

People want to understand their finances, but traditional budgeting apps force them into rigid dashboards, categories, and static UI. AskMyMoney flips it: your finances become fully conversational.

Instead of digging through statements, you ask things like:

• “Did I pay rent the last 3 months?”
• “What’s my burn rate this quarter?”
• “How much did I spend on restaurants in October?”
• “Summarize all income sources year-to-date.”

Everything is answered with live transaction data, inside ChatGPT.

---

Key features:

• Plaid integration: Securely sync accounts, balances, and transactions.
• Financial Q&A: Ask anything about spending patterns, balances, subscriptions, trends.
• Automatic transaction enrichment: Categories, merchants, recurrence detection.
• Multi-account support: Link multiple checking, savings, and credit cards.
• Personalized summaries: Daily/weekly/monthly insights with one prompt.

MCP tools for ChatGPT:

• list_accounts
• sync_transactions
• get_balances
• analyze_spending
• search_transactions
• (more coming)

These tools let ChatGPT pull structured, real financial data and ground its answers automatically.

---

How it uses the Apps SDK / what UI you’re rendering in ChatGPT:

• MCP tools power all financial operations (accounts, balances, transactions, syncing).
• Widgets built with Tailwind v4 + Framer Motion for:
  • account overviews
  • spending breakdowns
  • recurring subscription summaries
• Auth flow follows the ChatGPT OAuth sample pattern.
• ChatGPT receives structured JSON payloads on each tool call, letting it reason about the user’s finances without custom UI work.

---

Stack & tools:

• Node.js (TypeScript)
• Next.js 15 (App Router)
• TailwindCSS v4
• Framer Motion (ChatGPT widget animations)
• Plaid API (Accounts, Transactions, Identity)
• Drizzle ORM + PostgreSQL
• MCP (Model Context Protocol)
• Vitest for integration tests
• Vercel (frontend) + Neon (database)

---

Links:

• 30 Second Video walkthrough: Watch on Vimeo

---

Anything you’d love feedback on:

Best practices for typing Apps SDK properties.

[achieving100ms]

nice. One suggestion if I may. I saw all your initial widgets show a blank slate “no libability data available”.

I would suggest you to add a skeleton of the final UI instead, so that it does not look like the connection is broken. i.e: showing “no data available” when the user knows there is data, so you leave him wondering… is it broken?

here is an example of a loading skeleton we use for our asset widget

The skeleton looks very similar to the final UI, thus also ensuring the UI does not jump once it finished loading

[dtorourke01]

Im excited to be here, thank you for having me.

[dtorourke01]

App Name: Ultimate Broker Route (UBR)

One-liner:

A mobile-first lead routing app that tracks door-to-door activity, route metrics, and follow-ups like a game scoreboard.

What it does:

UBR helps field agents plan multi-day routes, track “stop outcomes,” and reset daily activity for performance coaching.

Built for insurance/Medicare/solar door-knockers and similar field sales roles.

Key Features:

• Multi-select stop outcomes

• Daily auto-reset

• Archive & route status tracking

• OCR-friendly structure for future upgrades

• Built in under 3 weeks using ChatGPT and no paid dev tools

Stack & Tools:

• Pure HTML/CSS/JS (client-side only)

• Runs offline / local file

• Designed and debugged with ChatGPT

Source Code:

Dropbox

I would love feedback on:

UI cleanup, next feature to add, best path to turn into a PWA.

[nicholas.dickey]

• App name: Findexar

• One-liner: Saas-In-A-Bottle for ChatGPT Apps and Agents

• Who it’s for / problem it solves:
  No-code, Vibe-code, Pro-code ChatGPT App and Agent Creators.
  Provides full SaaS functionality, the business operations layer for your App or Agent

• **Key features:
  Creator SaaS platform:

  • Bring your own stripe
  • Define subscription plans for your app
  • Findexar wraps your tools with SaaS layer, guard rails, billing, subscription management widgets.
  • Observability
  • Revenue and Usage dashboards

  User Sign-up/Login
  User Subscription Upgrade/Management widget right inside ChatGPT
  Coming Soon: Support escalation, queues, widgets**

• How it uses the Apps SDK / what UI you’re rendering in ChatGPT:
  Subscription Management tool (and coming soon Support tool) is a skybridge widget created with Apps SDK and injected in run-time into the upstream MCP server

• Stack & tools:
  Next.JS / Vercel / Neon / Redis / OpenAI Apps SDK.

• Link(s) findexar
  Youtube introduction video: @findexar
  Discord beta support channel: BAUgjwhd

• Anything you’d love feedback on:
  Take a look, kick the tires, watch the video. You can turn your app into a full-featured SaaS platform in under an hour! Let us know what you like about it, how we can make it better for you, and what questions do you have.

[dustin_wilson]

AutoAgent – A ChatGPT App for Real-Time Vehicle Inventory Search & Dealership Automation

App name: AutoAgent
One-liner: A ChatGPT-powered automotive agent that searches real dealership inventory, compares vehicles, and automates lead workflows using MCP + Apps SDK.

---

Who it’s for / Problem it solves

AutoAgent serves both auto dealership teams and everyday car shoppers, solving major pain points on both sides of the buying journey.

For dealerships, AutoAgent unifies fragmented systems—inventory tools, CRM portals, OEM dashboards, spreadsheets, and website lead forms—into a single conversational interface inside ChatGPT. Sales teams get instant access to real-time inventory, vehicle details, and lead routing without switching between multiple outdated systems. This cuts response times, reduces manual lookup, and keeps teams focused on customers instead of software.

For consumers, car shopping is often overwhelming: too many filters, inconsistent listings, complex trim names, buried package details, and third-party sites with stale data. AutoAgent turns the experience into a natural conversation—ask “show me trucks under $40K,” “compare these two VINs,” or “which trims have Apple CarPlay?” and get accurate results directly from a dealership’s live inventory. It feels like having a knowledgeable salesperson available on demand.

---

Key features

• Search Vehicles (MCP Tool) — Real-time inventory search via MarketCheck + custom dealership APIs

• Vehicle Results Widget — Interactive browsing UI inside ChatGPT

• VIN Comparison + Trim Insights

• Lead Submission Tool — Sends leads to CRM or email

• Diagnostic Tools — pingUi, pingMicroUi, and status checks

• Secure environment handling for dealership partners

• Dealer dashboard for internal analytics (Next.js)

---

How it uses the Apps SDK

AutoAgent integrates deeply with the ChatGPT Apps SDK:

• MCP connector (Node.js/Express + TypeScript)

• App manifest referencing MCP tools + widget endpoints

• Custom widget UI for vehicle browsing and comparisons

• ui:ready and global state synchronization

• ChatGPT-driven multi-step workflows for search → compare → lead submission

This lets ChatGPT act as an intelligent automotive assistant powered by real dealership data.

---

Stack & tools

• Next.js 15 (App SDK manifest + dealer dashboard)

• Node.js / TypeScript MCP server (Express)

• Supabase (database + auth)

• Docker (containerization)

• Railway / Cloudflare (planned hosting)

• MarketCheck API (inventory + VIN decoding)

---

Links

We’ll be sharing the repo and public deployment soon after finalizing our production MCP endpoint + manifest wiring.

---

Anything you’d love feedback on

We’re particularly interested in:

• MCP CORS best practices (HEAD/OPTIONS handling, strict origins)

• Patterns for widget → ChatGPT global state sync (set_globals, ack_globals)

• Recommended hosting setups for stable MCP production use

• Tools/connector structuring within larger monorepos

• Any examples of high-performing real-time data apps in the Apps SDK

We’ll continue updating this thread as AutoAgent progresses.
Excited to see what everyone else is building!

[zhongxinuk]

Texas Duel – a ChatGPT-native poker app for real-time play, settlement, and post-hand analysis.

What it does

• Runs full NLHE hand cycles right inside the chat: deal hole cards, betting (call/raise/fold), board dealing, showdown, and bankroll updates—hand after hand.

• Great for learners who want “play-to-learn,” coaches demoing concepts, and creators building interactive content.

• Privacy-aware UX: your hole cards are shown only in a widget (client-only); the model cannot see them.

How you built it

• ChatGPT Apps tool-calling powers a poker engine:

  • poker.start_hand shuffles and deals hole cards .

  • poker.deal deals flop/turn/river in order.

  • poker.shutdown performs showdown, hand evaluation, and settlement.

• A front-end widget renders your hole cards and the board; the AI only receives state it’s allowed to see.

• Pot and stacks are tracked in-session with automatic EV/odds-aware settlement.

3rd party APIs / integrations

• ChatGPT Apps / Tools (tool-calling + widget).

• A custom Poker Engine API (shuffling, dealing, hand evaluation, settlement).

Tech stack

• Backend: Node.js/TypeScript poker engine

• Frontend: Apps SDK Widget (React) for cards & interactions.

• Hosting: serverless.

• State: in-session memory + light KV/Redis for game_id→state and idempotency.

Interesting patterns

• Model-invisible / client-only information isolation to prevent “card peeking.”

• Multi-step, turn-based tool-calls (pre-flop → flop → turn → river → showdown) with idempotent retries.

• Auto settlement & review: declares the winner, updates bankrolls, and can output improvement tips.

• Extensible to animations, multi-player tables, leaderboards, and EV training modes.

Screenshots or short video (optional)

• 

[Pascal_Briod]

App name: Monito - Money Transfer Comparison

One-liner: Compare dozens of international money transfer providers to find the cheapest option to send money abroad.

Who it’s for / problem it solves: A tool for people making international money transfers (supporting their family, moving their savings to a new country, investing abroad, travelling, etc.), helping them find the provider offering the lowest fees and best exchange rates for a specific money transfer.

Key features: Live comparison of money transfer providers fees and exchange rates for a specified transfer (currencies, amount, pay-in and pay-out methods, etc.). Users can compare promotions and indicate if they already have accounts with some providers to compare them against the competition.

The tool uses the same API powering our comparison website Monito, which collects data from dozens of different providers in real-time.

Link(s): The forum interface doesn’t let me share links in there, but I’m happy to share the link to install our app in ChatGPT to anyone reaching out to pascal@monito.com

We’d love to get feedback on whether the UI we’ve built is well-integrated within the ChatGPT conversation, and if there’s anything we could improve on how we influence the messages added by ChatGPT below our widget.

[hunter.hillegas]

• App Name: Enzo Reader
• One Liner: Brings your existing RSS and similar type feed subscriptions into ChatGPT. Read, triage or chat with the model about the specifics.
• What It Does: Uses your subscription to services like Feedbin, et al to bring a complete feed reading experience into ChatGPT allowing you to have access to what you’ve been reading in your chats.
• How It’s Built
  • Ruby on Rails backend w/ PostgreSQL+pg_vector + the official Ruby MCP gem
  • Devise+Doorkeeper for OAuth w/ DCR
  • React front-end
  • OpenAI ChatGPT UI components

As far as feedback:

• If I send a message to the model with sendFollowUpMessage, there’s no visual feedback at all that this is happening other than the progress indicator going to the stop sign, it’s very subtle.
  • And even when it does start generating content, the latest part of the message may be out of the viewport - the user doesn’t think the button they pressed did anything.
    • Is it a developer responsibility to do something like pop up an alert to say “scroll down to see the output" or something like that? Just seems sort of odd for the presence of new content to not be indicated somehow.
• On iPad at least, fullscreen mode overlaps window controls, clock, etc.
  • iOS has safe area insets to avoid that stuff that doesn’t appear to be respected by the App infrastructure overall, trying to render in places that it should not.
• I understand why developer mode is a thing but toggling it is a PITA.
  • The keyboard shortcut works like 50% of the time.
  • Maybe it could be per window instead of global? Or you only need it on when you create a custom/unapproved app and not when using/testing it?
• Documentation improvements.
  • Better than average but something like the Reference page in the SDK docs could have a lot more specifics about what some of those properties do including examples.

[achieving100ms]

Nice. I could see myself giving the RSS a try.

@hunter.hillegas

fullscreen mode overlaps window controls, clock, etc.

Doesn’t the same safe area insets work as on iOS?

@hunter.hillegas

Or you only need it on when you create a custom/unapproved app and not when using/testing it?

I think so. They say there will be a review process, so it would make sense that once we pass that process, users would not need to be in “developer” mode.

[hunter.hillegas]

Yeah, it’s pretty fun actually. Been using it a lot myself.

On the safe area insets, I know the SDK surfaces something it calls safe area insets also but I was thinking more that it’s weird the ChatGPT app on iPad renders in no-go areas at all so really more of an app issue, not SDK specific. Doesn’t seem like it should let a developer put stuff in an area that the OS has rendered into, it just looks really bad with buttons over the status bar.

Oh also, one I forgot to mention in my post: it seems like only the last rendered version of a widget’s buttons work? i.e. if I render one widget and then actions result in another copy rendered later in the chat, if I go back to the first one, the buttons just do nothing. Only the buttons on the most recent render work.

[fredisterik]

Day 1 - Advent of ChatGPT Apps

App name: Time’s Up

One-liner: Draw a card, give clues, make ChatGPT guess your word

Who it’s for / problem it solves: Anyone who wants to play word-guessing games with ChatGPT. Solves the fundamental problem of vanilla ChatGPT: without actual cards, there’s nothing stopping either player from changing their word mid-game or claiming they had a different one all along.

Key features:

• Deck of word cards across 5 languages ( )
• ChatGPT genuinely can’t see the word it’s guessing, User can’t change its word mid-game - no cheating

How it uses the Apps SDK / what UI you’re rendering in ChatGPT: Uses a widget to display cards drawn from the app. Word is packaged in the meta property in tool responses—making the word visible to the UI but completely invisible to the model. ChatGPT calls another tool to check if each guess is correct, creating true information asymmetry.

Stack & tools: Typescript mono-repo bootstrapped from alpic-ai/apps-sdk-template with MCP server SDK and React. Using skybridge framework for convenient hooks and HMR with Vite. Hosted on Alpic.

Link(s):

• Try it for yourself: times-up.alpic.live
• Check out the source code on Github on fredericbarthelet/advent-chatgpt-app

Can you figure out how a player might still cheat?
What other asymmetric games would benefit from this “hidden information” approach?

[jeffvpace]

Well, i am not part of the OpenAI team, but

• This requires an agent(s) to have full access to my Schwab trading account, correct?
• And the agent(s) can place limit orders?
• Do you have a deal with Schwab and the other trading platforms?
• How do you get real-time quotes exactly?
• Do you have an auditor?
• What are the risks? How do you ensure against rogue agents?

I have so many questions I don’t know where to begin.

Many years ago, I (and my team) developed and sold a real-time platform to TD Ameritrade, which eventually became thinkorswim and was recently bought by Schwab. So, I’m having a hard time believing that you have accomplished all this. Convince me.

[Pedro_Rodrigues1]

Day 2 - Advent of ChatGPT Apps
App name: Study Buddy

One-liner: Your personal language tutor that creates custom flashcards for learning Spanish, French, German, Italian, and Portuguese

Who it’s for / problem it solves: Travelers and language learners who want personalized vocabulary practice. Solves the friction of traditional language learning apps that force you into rigid, one-size-fits-all curricula—instead, you simply tell ChatGPT what you want to learn and get instant, contextual flashcards.

Key features:

• Multi-language support across 5 European languages
• ⁠Adaptive difficulty levels (beginner, intermediate, advanced)
• ⁠Topical organization (food, travel, business, greetings…)
• ⁠Interactive flip cards with progress tracking

How it uses the Apps SDK / what UI you’re rendering in ChatGPT: Renders interactive flashcard widgets directly in the chat interface. Users can flip cards, mark progress, and navigate through decks without leaving the conversation. ChatGPT dynamically generates personalized vocabulary sets based on conversational requests, then presents them as polished, study-ready flashcards through the widget interface.

Stack & tools: TypeScript with Supabase backend for deck persistence, auth, and progress tracking. React components for the flashcard UI. Hosted on Alpic.

Link(s):

• Try it for yourself: study-buddy.alpic.live
• ⁠Check out the source code on GitHub at Rodriguespn/study-buddy-app

[deanvmauro]

@jeffvpace the old TD Ameritrade was fantastic. Very cool to be talking with you.

Let me give a clear rundown:

Does this require full access to my Schwab / brokerage account?

No. Users connect via OAuth so permissions are strictly scoped to trading + account-read access. It’s not possible for us to see credentials, transfer funds, or take custody of assets, and users can revoke access entirely at any time from their brokerage.
From Schwab’s developer portal:

Can the agent place limit orders?

Yes. Limit, market, stop, stop-limit. Every order is previewed in plain language and requires explicit user confirmation before execution.

Do you have a deal with Schwab / exchanges?

Nothing special. We integrate through each broker’s publicly supported API if they have one. These are the same partner APIs used by apps in their ecosystems. No private agreements needed.

Granted, Schwab does have a lengthy approval process to gain access to their API and it took ~10 months to do. Some brokerages, like Fidelity, don’t offer a trading API at all so we can’t connect to them.

How do you get real-time quotes?

There are a number of market data providers but we use Alpaca and TwelveData. Alpaca happens to be one of ChatGPT’s first App partners too:

Do you have an auditor?

We’re following the standard fintech compliance playbook: logging, monitoring, scoped permissions, and a clear audit trail for every order. Independent auditing is planned as we scale; absolutely agree on its importance.

How do you protect against rogue agents?

All orders are created in draft mode and require the user to confirm before they’re placed on the brokerage. I’m not sure if agents can use apps yet but this restriction would still be in place. If users really want to give an agent the keys to the castle, we have an auto-execute setting they can turn on, but that’s up to them.

We already released an MCP server and custom GPT. The App is just the next stage of evolution. Would love to have you try it out and get your feedback.