I Built a Turkish Anime & Manga Ecosystem in About 30 Days with ChatGPT — Website, API, Chrome Extension & Android App
About a month ago, Nozu was mostly an idea.
I wanted to build something for the Turkish anime and manga community: not just another anime database, but a platform where Turkish users could discover series, keep their lists, track their progress, interact with other users and access the same data from different devices.
I also wanted developers to be able to use that data freely in their own projects.
Approximately 30 days later, that idea has turned into an interconnected ecosystem consisting of:
- A Turkish anime & manga database
- A public REST API
- A Chrome extension
- A native Android application
- Anime and manga tracking
- Episode progress
- Ratings and favorites
- Custom lists
- User profiles
- Followers and following
- Comments and @mentions
- Notifications
- Characters, voice actors, staff and studios
- Relations and recommendations
- Advanced search and discovery
- Cross-platform synchronization
- OpenAPI documentation
- Developer examples for multiple languages
And I built almost all of it as a solo developer with ChatGPT as my development assistant.
It Started Much Smaller
When I first publicly shared Nozu, the project was still very young.
The website was running on an early test environment, the design was completely different, parts of the platform were still throwing development errors, and the database was still being populated.
At that stage, I had just over a thousand anime records available.
Only a few days later, the database had already grown into tens of thousands of anime and manga records, with a much larger import queue still being processed.
I had also built:
- Automated data synchronization
- Turkish translation pipelines
- Image/CDN infrastructure
- A public API
- A Chrome extension
- A redesigned interface
The project was changing so quickly that I eventually had to create a dedicated changelog because I could no longer reliably remember every feature and improvement I had added.
Why Build Another Anime Database?
One of the first reactions I received was essentially:
MyAnimeList already exists. Why would I use another platform?
And that is a perfectly reasonable question.
My goal is not to pretend that Nozu can replace decades-old international platforms overnight.
MyAnimeList, AniList and Kitsu already exist and provide excellent services.
But that does not mean there is no room for alternatives.
The main difference is that Nozu is being designed around the Turkish anime and manga community from the beginning.
I wanted Turkish users to have:
- Turkish descriptions
- A Turkish-first interface
- Anime and manga tracking
- Modern discovery tools
- Characters and voice actors
- Social features
- An API Turkish developers can use
- A platform that does not require them to depend entirely on foreign services
The API itself is still open internationally.
You don't need to be Turkish to use it.
The Database Is Not Just a Proxy
One architectural decision was especially important to me.
I did not want Nozu to simply request information from another API every time a user opened a page.
The data is imported, processed and stored in Nozu's own database.
External sources are periodically checked for changes, and existing records can be updated automatically.
This means Nozu is building and maintaining its own usable catalogue instead of merely acting as a temporary frontend for another service.
The system has also gone through several iterations of translation infrastructure.
I initially experimented with traditional translation services before eventually moving toward AI-assisted translation because of cost, quality and scalability considerations.
The translations are not treated as perfect. They can still be reviewed and improved over time.
One Account, Three Platforms
This eventually became one of my favorite parts of the project.
Nozu is no longer just a website.
Today there are three user-facing parts:
Website
Chrome Extension
Android Application
Currently in closed beta.
The Android application is planned for Google Play release around August 23, 2026, assuming the current testing process completes as expected.
But the important part is that these are not three independent products.
They are connected to the same Nozu account.
Update Something Once, See It Everywhere
Imagine that you are browsing an anime website with the Nozu Chrome extension installed.
You add an anime to your list.
Or you say:
"I've watched 7 episodes."
That information is saved to your Nozu account.
When you later open:
Nozu.me
the anime is already in your list and your progress is already at episode 7.
Open the Android application and the same information is there as well.
The same works in the opposite direction.
Update your progress from the Android application and the website sees the change.
Change your list status from the website and the other clients use the same information.
The basic idea is:
One account. One library. Multiple platforms.
The Chrome Extension
The Chrome extension originally started as a small experiment.
The first working prototype took me roughly 20 minutes to build with ChatGPT.
Its first job was simple:
Detect the title of an anime or manga on the page the user was viewing, search Nozu and display the corresponding information.
That experiment eventually became the Nozu Anime Yardımcısı extension available on the Chrome Web Store.
Today I see the extension primarily as a companion to the main Nozu ecosystem rather than a completely separate product.
The important part is the integration.
A user should not care whether an action was made from the browser extension, website or Android application.
The account should simply stay synchronized.
Then I Built the Android App
After the website and Chrome extension were working, I moved on to a native Android application.
This was also built as part of the same roughly month-long development period.
The application is currently in closed beta testing.
Instead of simply wrapping the website in a WebView, I decided to build the application using Flutter and connect it to Nozu through the API.
That meant the API stopped being only a feature for external developers.
It became an important part of Nozu's own architecture.
The mobile application consumes the same platform data that external developers can access through the public API.
The Nozu API
Nozu provides a free public REST API for anime and manga data.
Base URL
https://nozu.me/api/v1
Public endpoints currently do not require an API key.
A basic search:
GET https://nozu.me/api/v1/search?type=anime&q=naruto
JavaScript:
const response = await fetch(
'https://nozu.me/api/v1/search?type=anime&q=naruto'
);
const data = await response.json();
console.log(data);
Some available endpoints include:
GET /search
GET /discover
GET /trending
GET /popular
GET /season-popular
GET /latest
GET /random
GET /autocomplete
GET /anime/{slug}
GET /manga/{slug}
GET /recommendations/{slug}
GET /studios
GET /studios/{slug}
GET /people
GET /people/{slug}
GET /characters/{slug}
GET /users/{username}
The API exposes information around:
- Anime
- Manga
- Characters
- Voice actors
- Staff
- Studios
- Relations
- Recommendations
- Public profiles
- Anime lists
- Manga lists
Full documentation:
OpenAPI specification:
https://nozu.me/api/v1/openapi.json
Developer-Friendly From the Beginning
As Nozu grew, I realized that simply exposing endpoints was not enough.
An API should also be easy to understand.
So I started building a small developer ecosystem around it.
The project now has:
- OpenAPI documentation
- Public GitHub documentation
- JavaScript examples
- Python examples
- PHP examples
- Flutter / Dart examples
- Postman-compatible API definitions
My goal is that someone should be able to discover Nozu and make their first successful API request within minutes.
Community Feedback Changed the Project
Sharing the project publicly was surprisingly useful.
Some people understandably asked why another anime platform was necessary when MAL and AniList already existed.
Others immediately saw value in having a Turkish alternative.
More importantly, one developer told me that he actually wanted to integrate the Nozu API into his own anime project.
That feedback introduced a question I had not initially considered deeply enough:
Can another developer trust this API to still exist six months from now?
That pushed me to think more seriously about sustainability.
I migrated away from the original test server, moved Nozu to its long-term infrastructure and started paying much more attention to stability, caching, API documentation and predictable updates.
That discussion improved the project.
Surprisingly Cheap to Operate
Another thing that surprised me was the cost.
Looking at Nozu from the outside, it can sound expensive:
- Large database
- Server infrastructure
- API
- Translation processing
- Image storage/CDN
- Website
- Chrome extension
- Native mobile application
But in practice I designed the infrastructure around my actual scale instead of overengineering it for millions of users I don't have.
As a result, both the development and current operating costs have been much lower than I initially expected.
I did not need:
- A development team
- An agency
- Multiple backend developers
- A dedicated mobile developer
- A separate frontend team
Most importantly, I didn't have to spend thousands of dollars just to validate the idea.
AI-assisted development made that possible.
What "Built with ChatGPT" Actually Means
I want to be clear about this part.
When I say:
"I built Nozu with ChatGPT"
I don't mean that I wrote one prompt and received a complete production platform.
That is not how it worked.
ChatGPT became something closer to an always-available development partner.
I used it while working on:
- Laravel backend code
- Database architecture
- API design
- Query optimization
- Queue workers
- Translation pipelines
- Server deployment
- Nginx configuration
- Flutter
- Android debugging
- UI iterations
- REST endpoints
- OpenAPI
- Documentation
- Chrome extension logic
- Search
- Notifications
- User lists
- Synchronization
- Bug fixing
Sometimes the first solution worked.
Sometimes it didn't.
Sometimes I spent a long time debugging a solution that looked correct but wasn't.
I still had to understand what I wanted, make architectural decisions, test everything, examine logs, deploy changes and decide whether the result was good enough.
But ChatGPT dramatically reduced the distance between:
"I want this feature"
and
"I have a working version of this feature."
I Redesigned Some Things Four Times
AI made iteration cheap.
That changed how I approached development.
For example, I redesigned the profile system multiple times.
At one point I was already on Profile V4 because I kept looking at the previous result and thinking:
This works, but I don't like it.
So I changed it again.
The same happened with the overall visual language.
The early Nozu interface used a dark purple-heavy design.
Later, I replaced it with a much brighter, cleaner and more minimal interface.
Traditionally, repeatedly rebuilding parts of a product can become extremely expensive.
With AI-assisted development, throwing away an idea and trying another became much less painful.
What Exists Today
The project now includes considerably more than the original anime database.
Some of the systems currently implemented include:
Profiles & Social
- Public profiles
- Profile banners
- Followers
- Following
- Profile statistics
- Public watch lists
- Anime taste statistics
Lists
- Anime tracking
- Manga tracking
- Watch/read status
- Episode progress
- User ratings
- Favorites
- Custom named lists
Community
- Anime and manga comments
- Comment editing
- Comment deletion
- @user mentions
- Media attachments
Notifications
- Website notification center
- Unread counters
- Mention notifications
- User notifications
- Admin-generated notifications
- Targeted notifications
- Bulk notifications
Discovery
- Trending
- Popular
- Latest
- Upcoming
- Random discovery
- Genre discovery
- Mood-based discovery
- Recommendations
- Similar titles
Media Information
- Characters
- Voice actors
- Staff
- Studios
- Relations
- Recommendations
- Similar content
And the list keeps growing.
About 30 Days
This is probably the part that surprises me the most.
Almost everything described above was built or significantly developed within roughly one month.
Website.
Backend.
Database infrastructure.
REST API.
Chrome extension.
Android application.
Synchronization.
Profiles.
Lists.
Comments.
Notifications.
Search.
Discovery.
Developer documentation.
Deployment.
And many redesigns and bug fixes in between.
I was not working with a startup team.
I was largely building it alone with ChatGPT beside me.
And financially, it cost me surprisingly little.
What I Learned
The biggest lesson for me has not been that AI can replace developers.
It is something slightly different:
AI dramatically increases how far one motivated person can go.
A project that previously might have required several different skill sets can now at least be prototyped and developed surprisingly far by one person willing to learn, test and iterate.
You still need judgment.
You still need patience.
You still need to debug.
You still need to understand when the AI is wrong.
But the barrier between having an idea and building something real has become dramatically smaller.
Nozu probably would not have reached this stage this quickly without AI-assisted development.
What's Next?
Nozu is still actively being developed.
The Android application is currently going through closed beta testing.
I am continuing to improve:
- Data quality
- Turkish translations
- Search
- Profiles
- Recommendations
- Performance
- API documentation
- Mobile integration
- Cross-platform synchronization
I also want the API to become useful outside Nozu itself.
If another developer can use Nozu to build:
- A Discord bot
- An anime application
- A recommendation system
- A Turkish anime project
- Something I never thought of
then that is a success for me.
Nozu
🌐 Website
https://nozu.me
📚 API Documentation
https://nozu.me/api
🧩 Chrome Extension
https://chromewebstore.google.com/detail/nozu-anime-yardımcısı/kmneeifhdnckmmhffhfejkcfgaicpfae?hl=tr
📄 OpenAPI
https://nozu.me/api/v1/openapi.json
💻 GitHub
https://github.com/Mangawt/nozu-api
Nozu started as an experiment.
About a month later, it has become:
Website → Database → REST API → Chrome Extension → Android App → One synchronized ecosystem.
And I'm still building.
Top comments (1)
One more thing that makes this project especially meaningful to me: I did all of this without having prior knowledge of any programming language.
When I started, I did not know Laravel, PHP, JavaScript, Flutter, Dart, API design, server deployment, or most of the technologies that Nozu now uses.
I learned what I needed step by step while building the project, mostly by working with ChatGPT, testing things myself, breaking things, fixing them, reading logs, and trying again.
So Nozu was not built from years of programming experience.
It was built from curiosity, persistence, a lot of trial and error, and AI-assisted learning.
That is probably the part of the project I am most proud of.
🙂