No jargon. Just answers.

Appzentic is a platform where you describe the app you want in plain language, and AI builds it for you — including real iOS and Android apps you can install on your phone or publish to app stores. You don't need to write any code.

No. You just need to know what you want the app to do. The AI handles all the code. You can also ask the AI to explain what it built or to change anything — in plain language.

Almost anything: a coffee shop ordering app, a fan video platform, a Chinese learning app with daily streaks, a news aggregator, a personal finance tracker, a restaurant management tool. If you can describe it, we can build it. See our Showcase for examples.

You describe your app in the chat. The AI asks a few clarifying questions (like what features you need, who uses it, what data it handles), then generates real source code — Swift for iOS, Kotlin for Android, and your choice of backend language. It packages that code into installable files and deploys the backend to our servers. The whole process takes minutes, not months.

A simple app (with a few screens and a basic backend) typically takes 5–15 minutes from first message to downloadable build. More complex apps with many features may take longer, and you can iterate in multiple sessions.

Yes — you pick the AI from a dropdown at the top of the chat, and you can switch at any time, even mid-project. Currently available: Claude (the default, and the one we recommend for coding), GPT, Gemini, DeepSeek, GLM, and Kimi.

They all work on the same project files, so switching models doesn't lose your work — the new model picks up the conversation and the code exactly where the last one left off.

Yes. In My Profile → Build you can add your own API key for any supported model. When you do, your chat messages run on your key instead of ours — which means they don't count toward your daily message limit.

If you have a Claude subscription, you can add that instead of a pay-per-use API key. Keys are stored encrypted, shown masked, and you can delete them at any time.

iOS runs on iPhones and iPads (made by Apple). Android runs on phones from Samsung, Google, Xiaomi, and most other brands. They use different programming languages and are distributed through different stores (App Store for iOS, Google Play for Android). Appzentic can build for both, or just one if that's all you need.

A native app is built specifically for one platform using that platform's own tools — it's installed on your phone and can access the camera, notifications, and other hardware features. It feels fast and smooth.

A web app runs in a browser. No installation needed, but it can't do everything a native app can. Many other "app builders" actually create web apps disguised as native apps (called web view wrappers). Appzentic builds real native apps.

It depends. If your app just shows static content (like a menu or a calendar), it may not need one. But if users create accounts, store data, or interact with each other, you'll need a backend — a server that handles all the data and logic behind the scenes. The AI will ask and decide with you.

Think of an API as a waiter at a restaurant. Your app (the customer) tells the waiter (the API) what it needs. The waiter goes to the kitchen (the server/database), gets the data, and brings it back. APIs let your iOS app, Android app, and web app all talk to the same backend and get the same data.

iOS — Swift. Android — Kotlin.
Backend — Python (FastAPI), Go, or Java (Spring Boot).
Web — plain HTML/CSS/JavaScript, or a React / Vue single-page app.

If you don't have a preference, just say so and the AI will pick what fits your app best. If you do have one, name it and the AI will use it. One project sticks to one backend language.

Three, and the AI picks based on what your app actually stores:

MySQL 8.2 — structured data with clear relationships: orders, users, products, payments.
MongoDB 6.0 — flexible documents where records don't all have the same fields: posts, content, activity feeds.
Redis 7.2 — fast temporary storage: sessions, caches, counters, leaderboards.

You don't set any of these up. Ask for what your app needs and the AI provisions it, with your app getting its own isolated database and credentials.

This is one of the biggest time-savers on the platform. Normally, adding these features means opening cloud accounts, verifying a business, and wiring up billing before you can write a single line. On Appzentic they're already running — the AI just switches them on for your app:

Sending email — verification codes, notifications, scheduled reports.
Voice & video calls — the relay servers (TURN/STUN) that make real-time calls work between phones on different networks.
Live streaming — publish a live video stream and play it back in your app.
File & media storage — user uploads, images, videos.
Scheduled jobs — code that runs on a timer, like a nightly report or a data sync.

These shared services are sized for prototypes and small audiences — enough to build the thing and show it to people. Once you have real traffic, the AI will tell you it's time to move that piece onto dedicated resources or a specialist provider.

Your app starts as source code — text files that describe how the app works. A "build" takes that code and compiles it into a single installable file that a phone can run: an APK or AAB for Android, or an IPA for iOS. Like turning a recipe into an actual meal.

For Android: scan the QR code in your build results to download the APK directly to your phone. You may need to allow "install from unknown sources" in your phone settings.

For iOS: we use Ad Hoc distribution. You register your iPhone once (see the UDID questions below), then every build you make produces a QR code — scan it and the app installs straight onto your phone. No App Store, no review, no waiting.

TestFlight is Apple's official beta-testing platform, and it's excellent — but it has two requirements that get in the way when you're just trying to see your idea running on your phone: every build waits for Apple's review, and you must already have created the app record in App Store Connect.

For someone testing a first version, that's a slow, discouraging start. So iOS testing on Appzentic currently uses Ad Hoc instead — your build is ready in minutes and installs immediately on any device you've registered. TestFlight support may return later for teams running wider beta programs.

Yes, for the web part. Ask the AI for a preview and it runs your web app and backend on a temporary address you can open in your browser right away — no build, no install. It's the fastest way to check a layout or test an API before committing to a full mobile build.

Mobile apps need a real build to run on a phone, but since the AI often builds the web version of your screens first, previewing is still the quickest way to react to a design early.

A UDID (Unique Device Identifier) is like a fingerprint for your iPhone — a long string of letters and numbers that identifies your specific device. Apple requires that any iOS app distributed outside the App Store must be registered to run on specific devices. Without your UDID, we cannot sign and package an iOS app that will actually install and run on your phone.

In the AI Build Console, we show you a QR code. Scan it with your iPhone's camera, open the link, and iOS will prompt you to install a small configuration profile (a standard Apple .mobileconfig file — the same mechanism used by corporate IT departments for work devices).

When the profile installs, your iPhone's UDID is sent to our server. That's the only thing we collect. The profile cannot access your photos, contacts, messages, location, or passwords. Apple strictly controls what configuration profiles are allowed to do.

You can review the profile's contents before installing — it will only show the device identifier. Once your UDID is registered, you can delete the profile immediately: go to Settings → General → VPN & Device Management, find the Appzentic profile, and tap Remove. Deleting the profile does not affect apps we've already built for your device.

Each physical iPhone has a different UDID. If you switch to a new phone, scan the QR code once more to register the new device. Your existing projects and sessions are unaffected — you're just adding a new device to the authorized list.

Yes. Appzentic builds the app package and helps you submit it. For Google Play you need a Google Play Developer account ($25 one-time fee). For the App Store you need an Apple Developer account ($99/year). Both are registered in your name — you own the listing, the reviews, the revenue.

Apple reviews each app before it goes live — typically 24–48 hours for most apps. Google Play is usually faster (a few hours to 3 days). Review times can vary based on complexity and how busy the stores are. New submissions take a little longer than updates.

Before an app can be distributed, it must be "signed" — digitally stamped to prove it came from a known developer and hasn't been tampered with. Both Apple and Google require this. If you want the app published under your developer account, you provide your signing certificate and we use it during the build process. Think of it as a wax seal on an envelope.

Google Play needs an AAB file rather than an APK, and it must be signed with a upload key that stays the same for the entire life of the app. Creating that key normally means running command-line tools most people have never touched — so we generate it for you, automatically, the first time your app needs one.

Download it and keep it safe. Go to My Profile → Android and download the keystore package for your app. It's a zip containing the key file and a small text file with its passwords — you'll need both if you ever publish outside Appzentic. Lose the upload key and you cannot ship updates to that listing again, so treat the zip like a house key.

Yes. Add your App Store Connect API key in your profile (the .p8 key file plus its Key ID, Issuer ID, and Team ID — all available from your Apple developer portal). Builds then get signed under your team, with certificates and provisioning profiles created in your own account.

If you don't add one, builds are signed with Appzentic's shared team so you can still test on your own devices. That's fine for trying things out — but to sell or list an app under your own name, you need your own Apple Developer account ($99/year).

Yes. Any project can be shared — invite a colleague, your boss, a client, or an intern into the same chat and you're all working with the AI in one conversation. Everyone sees the same messages, the same code, and the same build results, live, as they happen.

It's genuinely useful for showing progress: instead of exporting screenshots for a manager, you add them to the session and they watch the app come together.

Guests can read everything and talk to the AI — ask questions, request changes, join the discussion. What stays with you as the owner are the actions with real consequences: starting builds and deployments, connecting databases or storage, pushing to GitHub, exporting code, renaming and deleting the project, and inviting more people.

So a guest can help shape the app, but can't accidentally deploy it or delete it.

Use @. Typing @Claude (or any other model) sends that message to the AI and routes it to that specific model for that reply. Typing @ and a person's name addresses a human instead — the AI stays quiet and lets you talk among yourselves.

That way a group can debate an idea without the AI jumping in after every sentence, then bring it back in when you've decided what you want.

You do. The source code, the app binaries (APK, IPA), your user data, your store listings — all of it belongs to you. Appzentic is a tool you use to build; we don't claim ownership of what you create.

Yes, anytime, and in two ways.

Download a zip — the complete source for every part of your app: iOS, Android, web, backend, and docs. Hand it to a developer, edit it yourself, or host it somewhere else entirely.

Push to GitHub — connect your GitHub account and your project syncs to a repository you own. Add the SSH key from My Profile → GitHub to your GitHub account and the console pushes directly. Your project also gets a README and a CHANGELOG generated automatically, so the repo looks presentable rather than like a pile of machine output.

Either way, credentials and keys are stripped from the export — you get your code, not our secrets.

You have 30 days to export your code and download your build artifacts (APK, IPA files). After that, data is deleted from our servers. But once you've exported your code, you own it permanently — your app can keep running even if you never use Appzentic again.

Enter your email and we send you a verification code to confirm it's really yours. Type the code in, choose a password, and you're in. The email address matters — it's how we send you a reset link if you forget your password, and how we reach you about your account.

Use the Forgot password link on the login page. We email you a reset link; open it and set a new password. If the email doesn't arrive within a few minutes, check your spam folder before trying again.

Open My Profile → Feedback and submit a report. You can attach a screenshot, which is usually the fastest way to get a problem understood. We reply on the same thread, so you'll see the response in your profile rather than having to dig through email.

If the AI itself gets stuck on something that looks like a platform or environment problem, it will often suggest filing a report — that's a good signal to do it, since those issues generally can't be fixed from inside the chat.

Important notices appear in My Profile → Notifications, with a red dot when there's something new. Anything urgent — planned maintenance, a change that affects your apps — pops up directly so you don't miss it.

A visit is any request that reaches your app's server — either a web page load (someone opening your web app in a browser) or an API call (your mobile app requesting data from the backend, like loading a list of orders). Both count equally. This total is measured daily across all your apps combined.

Total Data Volume is the count of core business records stored in your app's database or file storage — things like user accounts, videos, images, orders, products, messages, and other key data your app generates. It's not measured in bytes or megabytes, but in record count. A user registration = 1 record. A video upload = 1 record. An order = 1 record.

The action is blocked and a message explains exactly which limit you reached — messages, builds, deploys, or new projects. Nothing is lost: your project, your code, and your conversation are all still there.

Daily limits reset at midnight UTC. So in most cases the answer is simply to come back tomorrow. If you don't want to wait, you can add your own AI key (messages then don't count against you), spend referral credits, or upgrade your plan.

Credits are extra allowance on top of your plan. You earn them by inviting people — share your referral link from My Profile, and both you and the person who joins receive credits.

Credits are spent before your plan's own quota, and they stay usable even after you've exhausted the free tier — so they're a genuine way to keep building without subscribing yet.

No — the free plan is a 30-day trial, and it also has a one-time total allowance across those 30 days on top of the daily limits. When either the 30 days or that total runs out, building pauses until you subscribe.

What doesn't stop: you keep full access to everything you've made. Viewing, exporting, downloading your builds, and pushing to GitHub all keep working. We won't lock you out of your own code to pressure you into paying.

You can upgrade to a higher plan, or purchase dedicated private resources — your own server, database or storage. Apps running on dedicated resources don't count toward your plan quota at all. Get in touch and we'll size it to what you actually need.

Before asking the AI to start writing code, spend a few messages confirming what you actually want. Ask things like: "I want users to be able to do X — what do you think is the best way to build that?" or "Here's what I'm imagining — does that make sense? Any better approach?"

Getting the requirements right upfront saves a lot of back-and-forth later. A few minutes of clarifying conversation can save hours of rework.

The AI may offer to sketch out a design or generate a preview. If you want to see it before coding starts, ask for a web page preview rather than a static image — it's more realistic and closer to what the actual app will look like.

That said, if you trust the AI's judgment on design, you can also just say: "Do what you think is best for the UI — no need to preview first." This speeds things up when you're not attached to a specific layout.

Once the AI finishes coding, ask: "Did you test this? Especially the backend API?"

For server-side code, the AI can run the actual API and check if it responds correctly — this is fast and reliable. For frontend HTML/CSS/JS, ask: "Did you validate the syntax?" Catching issues before you try to install or run the app saves a lot of time.

For coding, always use Claude. It has the strongest programming ability — it writes cleaner code, catches more edge cases, and handles complex tasks better than other models. It's the default for exactly this reason.

For general questions, brainstorming, or quick answers, GPT, Gemini, DeepSeek, GLM, and Kimi all work fine and can be faster on straightforward tasks.

You can switch models mid-project without losing anything — so a practical pattern is to explore an idea on a cheaper model, then switch to Claude when it's time to actually write the code.

Every modern browser has a built-in Developer Tools panel (press F12 or right-click → Inspect). It's essential for testing web apps:

Network tab — shows every API request your app makes. If something fails, you'll see the error code and the server's response right there.
Console tab — shows JavaScript errors with exact line numbers.
Elements tab — lets you inspect any button, text, or layout element.

When reporting a problem to the AI, copy the exact error message from DevTools — or paste the relevant HTML element — instead of describing it verbally. Precise input = precise fix. You can also take a screenshot, highlight the problem area, and paste the image directly into the chat. The AI understands images.

Build failed? Copy the full build log and paste it into the chat. The AI will immediately identify which step failed and why — guessing from a description wastes time.

App looks wrong on your phone? Take a screenshot and paste it directly into the chat. Describe what you expected and what you got. The AI can see the image and suggest precise fixes.

Complex behavior bugs? Ask the AI to add log output to the app and add a button that exports the runtime log to a file. You can then share the log with the AI, and it can trace exactly where the logic broke down. This is especially useful for tricky iOS or Android bugs that are hard to reproduce.

Don't describe your entire app in one message and expect it to be perfect on the first try. Build one feature, test it, then move on to the next. This keeps each conversation focused, makes bugs easier to isolate, and lets you course-correct before too much work piles up.

When you have a question or find an issue, say which platform it's on: "This happens on the iOS app" or "The Android button is misaligned" or "The web page returns an error." The AI handles iOS, Android, and web differently — being specific gets you the right fix faster.

Sometimes you send a message — asking the AI to design a plan, write some code, fix a bug, optimize a feature, answer a question, or organize some data — and the response stops halfway, errors out, or just never comes. Don't panic. You have two options:

Resend the message — hit the resend button on your previous message to retry the exact same request.

Follow up in plain language — just type something like: "What happened with that task? Did it fail?" or "The last step didn't seem to finish — can you check and retry?"

The AI can see the conversation history and will pick up from where it left off, diagnose what went wrong, and try again.