{"id":1146,"date":"2026-07-04T06:07:33","date_gmt":"2026-07-03T23:07:33","guid":{"rendered":"https:\/\/sumberlaba.com\/index.php\/2026\/07\/04\/the-ultimate-guide-to-building-a-fully-functional-calorie-tracker-app-from-scratch\/"},"modified":"2026-07-04T06:07:33","modified_gmt":"2026-07-03T23:07:33","slug":"the-ultimate-guide-to-building-a-fully-functional-calorie-tracker-app-from-scratch","status":"publish","type":"post","link":"https:\/\/sumberlaba.com\/index.php\/2026\/07\/04\/the-ultimate-guide-to-building-a-fully-functional-calorie-tracker-app-from-scratch\/","title":{"rendered":"The Ultimate Guide to Building a Fully Functional Calorie Tracker App from Scratch"},"content":{"rendered":"<h1>The Ultimate Guide to Building a Fully Functional Calorie Tracker App from Scratch<\/h1>\n<p>In today\u2019s health-conscious world, tracking daily calorie intake has become a cornerstone of weight management, athletic performance, and general wellness. Building your own calorie tracker app not only gives you complete control over your data, but it also provides a deep learning experience that spans database design, API integration, user authentication, and real-time data visualization. A well-constructed calorie tracker goes far beyond a simple number counter; it must handle a vast food database, support barcode scanning for quick entry, allow manual entries for custom meals, calculate macronutrient breakdowns, and present progress through clear, motivating charts. Whether you are a solo entrepreneur aiming to launch a health app or a developer looking to expand your portfolio, creating a calorie tracker from scratch will sharpen your skills and teach you how to build a production-ready application.<\/p>\n<p>This tutorial will walk you through the entire process of building a cross-platform calorie tracker app using React Native with Expo for the frontend, Firebase for backend services (Authentication, Firestore, and Cloud Functions), and the Nutritionix API for reliable food data. React Native and Expo allow you to target both iOS and Android simultaneously, while Firebase eliminates the need to manage your own server infrastructure. We will cover everything from initial planning and environment setup to implementing advanced features like offline caching and weekly chart generation. By the end of this guide, you will have a fully functional app that users can sign into, search for foods, log meals, set daily calorie goals, and view their progress over time. Expect to invest several days or weeks depending on your familiarity with the technologies, but the modular steps below will keep you on track. Let\u2019s begin with the most critical phase: planning your architecture.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/via.placeholder.com\/800x600\/4a90d9\/ffffff?text=how%20to%20build%20a%20calorie%20tracker%20app\" alt=\"Article illustration\" style=\"display:block;margin:20px auto;max-width:100%;height:auto;border-radius:8px;\" \/><\/p>\n<h2>Step 1: Planning Your App Architecture and Feature Set<\/h2>\n<p>Before writing a single line of code, you must clearly define what your calorie tracker will do. A successful app solves a real problem for its users: making calorie tracking quick, accurate, and habit-forming. Start by listing the core features that every viable calorie tracker must have. The most essential capabilities include a food search function that queries a large, up-to-date nutritional database; a manual entry mode for home\u2011cooked meals or packaged foods not found in the database; the ability to log foods into separate meal categories (breakfast, lunch, dinner, snacks); a daily progress bar that compares consumed calories against a user-defined goal; and historical data visualization, such as a week\u2011over\u2011week bar chart. Secondary features like barcode scanning, recipe creation, and water tracking can be added later, but focus first on the foundation.<\/p>\n<p>Choosing the right technology stack is equally important. For the frontend, React Native with Expo provides a fast development cycle and access to native device features (camera for barcode scanning) without needing separate codebases. For the backend, Firebase\u2019s Firestore offers a flexible, real\u2011time NoSQL database that scales easily, while Firebase Authentication handles user sign\u2011up and login with email\/password or social providers. To fetch nutritional data, the Nutritionix API is a popular choice because it covers hundreds of thousands of branded and generic foods, returns detailed macros, and has a generous free tier. Alternatively, you could use the Edamam API, but Nutritionix is more straightforward for this use case. Finally, for data visualization, the react\u2011native\u2011chart\u2011kit library works well for bar and line charts. The table below outlines each feature and its recommended implementation.<\/p>\n<table border=\"1\" cellpadding=\"8\" cellspacing=\"0\" style=\"border-collapse: collapse; width: 100%; margin: 20px 0;\">\n<thead>\n<tr>\n<th>Feature<\/th>\n<th>Implementation Approach<\/th>\n<th>Key Technology<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>User authentication<\/td>\n<td>Email\/password or Google sign\u2011in<\/td>\n<td>Firebase Authentication<\/td>\n<\/tr>\n<tr>\n<td>Food search (text query)<\/td>\n<td>Send query to Nutritionix natural language endpoint<\/td>\n<td>REST API (fetch)<\/td>\n<\/tr>\n<tr>\n<td>Manual food entry<\/td>\n<td>User inputs calories, protein, carbs, fat; stored as custom food<\/td>\n<td>Firestore collection &#8220;customFoods&#8221;<\/td>\n<\/tr>\n<tr>\n<td>Meal logging<\/td>\n<td>Each log entry includes food ID, meal type, date, serving size<\/td>\n<td>Firestore collection &#8220;foodEntries&#8221;<\/td>\n<\/tr>\n<tr>\n<td>Daily calorie progress<\/td>\n<td>Aggregate entries by date; compare to daily goal (stored in user profile)<\/td>\n<td>Firestore queries + client\u2011side calculation<\/td>\n<\/tr>\n<tr>\n<td>Weekly chart<\/td>\n<td>Fetch last 7 days&#8217; totals; render bar chart<\/td>\n<td>react\u2011native\u2011chart\u2011kit<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2>Step 2: Setting Up the Development Environment<\/h2>\n<p>With your feature list finalized, it is time to set up your development environment. Begin by installing Node.js (version 18 or newer) on your machine if you do not already have it. Then install Expo CLI globally using the command <code>npm install -g expo-cli<\/code>. Once that is done, create a new Expo project by running <code>expo init CalorieTracker --template blank<\/code> (the blank template gives you a clean starting point). Navigate into the project directory and install the core dependencies you will need: <code>@react-navigation\/native @react-navigation\/bottom-tabs @react-navigation\/stack firebase @react-native-firebase\/app @react-native-firebase\/auth @react-native-firebase\/firestore react-native-chart-kit react-native-svg async-storage<\/code>. Use <code>expo install<\/code> for packages that have Expo\u2011compatible versions. For the Nutritionix API, you will also need to sign up for a free account at developer.nutritionix.com and obtain an application ID and API key. Save these credentials in a <code>.env<\/code> file (using <code>react-native-dotenv<\/code> or a simple config file) so you never hard\u2011code sensitive keys.<\/p>\n<p>Next, create a Firebase project at console.firebase.google.com. Enable Authentication (start with Email\/Password) and create a Firestore database in test mode for development (you will tighten security rules later). Download the Google\u2011Services files (GoogleService\u2011Info.plist for iOS and google\u2011services.json for Android) and place them in the appropriate directories as per Expo\u2019s Firebase integration guide. At this point, you should also set up a Cloud Functions project if you plan to run periodic tasks like updating daily aggregates, but for this tutorial we will keep all aggregation client\u2011side to reduce complexity. Once your project is created and dependencies installed, run <code>expo start<\/code> to verify everything works on a simulator or physical device. Your app should display a blank screen, but the foundation is laid for the next steps.<\/p>\n<h2>Step 3: Designing the User Interface and User Flow<\/h2>\n<p>A well-designed user interface is crucial for a calorie tracker because users will interact with it multiple times daily. The primary user flow begins with authentication: a login\/signup screen, then the user lands on a dashboard that shows today\u2019s calorie summary. From the dashboard, the user can tap a \u201c+ Add Food\u201d button to search for a food item, see results, select one, choose a meal type and serving size, and log it. The logged entry immediately updates the dashboard\u2019s progress bar. Users can also navigate to a History screen to view previous days and see weekly charts, and a Settings screen to adjust their daily calorie goal, unit preferences, and account details. This flow can be implemented using React Navigation with a bottom tab navigator containing three tabs: Home, History, and Settings. Within the Home tab, you may optionally include a stack navigator for the search and manual entry screens.<\/p>\n<p>Design the Home screen to display a clean progress circle or horizontal bar showing current calories versus the daily goal, along with a breakdown by meal (e.g., Breakfast: 350 cal, Lunch: 580 cal). Use large text and intuitive colors (green when under goal, orange when nearing, red when over). The search screen should have a text input at the top with autocomplete suggestions as the user types, leveraging the Nutritionix natural language API endpoint. For manual entry, create a simple form with fields for food name, serving size (grams or ounces), and the four macronutrients. You can use libraries like <code>react-native-element<\/code> for standard input components, but plain React Native <code>TextInput<\/code> components work fine. Pay attention to keyboard handling \u2013 use <code>KeyboardAvoidingView<\/code> to ensure inputs are not hidden when the keyboard appears. A minimal wireframe for the Home screen might include a header with the date, a calorie ring chart, a list of meals with expandable entries, and a floating action button for adding food.<\/p>\n<h2>Step 4: Implementing User Authentication<\/h2>\n<p>User authentication ensures that each person\u2019s data remains private and synced across their devices. Using Firebase Authentication, you can implement a secure sign\u2011up and login flow with just a few lines of code. Start by setting up Firebase in your app: import the <code>firebase<\/code> module and configure it with your project\u2019s API keys. For a React Native Expo app, you can use the <code>@react-native-firebase\/app<\/code> package. In your <code>App.js<\/code> or a dedicated <code>AuthContext<\/code>, check if a user is already signed in when the app loads, and display the appropriate screens. Below is a simplified example of an authentication function:<\/p>\n<pre><code>\nimport auth from '@react-native-firebase\/auth';\n\nconst signIn = async (email, password) => {\n  try {\n    const userCredential = await auth().signInWithEmailAndPassword(email, password);\n    return userCredential.user;\n  } catch (error) {\n    console.error('Sign in error:', error);\n    throw error;\n  }\n};\n\nconst signUp = async (email, password) => {\n  try {\n    const userCredential = await auth().createUserWithEmailAndPassword(email, password);\n    return userCredential.user;\n  } catch (error) {\n    console.error('Sign up error:', error);\n    throw error;\n  }\n};\n<\/code><\/pre>\n<p>Additionally, implement a sign-out function and persist the user\u2019s authentication state using <code>onAuthStateChanged<\/code> listener. You should also handle password reset functionality. For a better user experience, consider adding social login options like Google Sign\u2011In; the Firebase console makes enabling these providers straightforward. Once authentication is in place, you can store each user\u2019s daily calorie goal in the Firestore document <code>users\/{uid}\/settings\/goal<\/code>. When the user signs in, fetch this goal and store it in your app\u2019s state. If the goal does not exist yet, prompt the user to set it during the first launch. This step is critical because all calorie tracking comparisons will rely on that numeric target.<\/p>\n<h2>Step 5: Building the Food Database Integration<\/h2>\n<p>The heart of any calorie tracker is its ability to provide accurate nutritional information for a wide variety of foods. The Nutritionix API offers a \u201cnatural language\u201d search endpoint that is incredibly user\u2011friendly: users can type something like \u201c2 eggs scrambled with cheese\u201d and the API returns a parsed result with total calories and macros. To integrate this, create a service file <code>nutritionixService.js<\/code> that holds your API credentials and exposes functions like <code>searchFoods(query)<\/code> and <code>getNutritionDetails(nixItemId)<\/code>. The search function sends a GET request to <code>https:\/\/trackapi.nutritionix.com\/v2\/search\/instant?query=${query}<\/code> with your app ID and key in the headers. The response includes both branded and common foods, each with a <code>food_name<\/code>, <code>serving_qty<\/code>, <code>serving_unit<\/code>, and <code>nix_item_id<\/code> for later detail requests. For example:<\/p>\n<pre><code>\nconst searchFoods = async (query) => {\n  const response = await fetch(`https:\/\/trackapi.nutritionix.com\/v2\/search\/instant?query=${encodeURIComponent(query)}`, {\n    headers: {\n      'x-app-id': APP_ID,\n      'x-app-key': APP_KEY,\n    },\n  });\n  const data = await response.json();\n  return data.common.concat(data.branded);\n};\n<\/code><\/pre>\n<p>When the user selects a food, you will need to fetch its full nutritional breakdown using the <code>nix_item_id<\/code> via the <code>\/v2\/search\/item?nix_item_id=...<\/code> endpoint. The response provides calories, protein, carbohydrates, fat, fiber, and many other nutrients. Store this information temporarily to allow the user to adjust the serving size before logging. For manual entries where the food is not in the database, you can save the custom food data in Firestore under a subcollection of the user\u2019s document, so it can be reused. To optimize performance and reduce API calls, consider caching common search results locally using AsyncStorage. The table below lists the most important fields returned by the Nutritionix item detail endpoint.<\/p>\n<table border=\"1\" cellpadding=\"8\" cellspacing=\"0\" style=\"border-collapse: collapse; width: 100%; margin: 20px 0;\">\n<thead>\n<tr>\n<th>Field Name<\/th>\n<th>Description<\/th>\n<th>Example Value<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>nix_item_id<\/td>\n<td>Unique identifier for the food item<\/td>\n<td>\u201c5fd3c1e3d3c3c3001f8b4567\u201d<\/td>\n<\/tr>\n<tr>\n<td>food_name<\/td>\n<td>Display name of the food<\/td>\n<td>\u201cChicken Breast, Roasted\u201d<\/td>\n<\/tr>\n<tr>\n<td>serving_qty<\/td>\n<td>Default serving quantity<\/td>\n<td>1<\/td>\n<\/tr>\n<tr>\n<td>serving_unit<\/td>\n<td>Unit of the serving (g, oz, cup, etc.)<\/td>\n<td>\u201coz\u201d<\/td>\n<\/tr>\n<tr>\n<td>nf_calories<\/td>\n<td>Calories per default serving<\/td>\n<td>165<\/td>\n<\/tr>\n<tr>\n<td>nf_total_fat<\/td>\n<td>Total fat in grams<\/td>\n<td>3.6<\/td>\n<\/tr>\n<tr>\n<td>nf_total_carbohydrate<\/td>\n<td>Total carbohydrates in grams<\/td>\n<td>0<\/td>\n<\/tr>\n<tr>\n<td>nf_protein<\/td>\n<td>Protein in grams<\/td>\n<td>31<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2>Step 6: Creating the Calorie Logging and Daily Tracker Logic<\/h2>\n<p>Once you have the food data and user authentication, the next step is to allow users to log a food entry and see it reflected in their daily progress. Design a Firestore collection called <code>foodEntries<\/code> with documents that contain fields: <code>userId<\/code> (string), <code>foodId<\/code> (string), <code>foodName<\/code>, <code>mealType<\/code> (enum: breakfast, lunch, dinner, snack), <code>calories<\/code> (number), <code>protein<\/code>, <code>carbs<\/code>, <code>fat<\/code>, <code>servingQty<\/code>, <code>servingUnit<\/code>, and <code>date<\/code> (timestamp or string in YYYY\u2011MM\u2011DD format). When the user saves an entry, write this document to Firestore. To display the daily total, query all entries for the current user where the <code>date<\/code> matches today\u2019s date. Then sum the <code>calories<\/code> field for all returned documents. You can either perform this query each time the Home screen loads, or use a Firestore snapshot listener to update the totals in real time (which is ideal for a seamless experience).<\/p>\n<p>A crucial aspect of the tracking logic is handling serving sizes correctly. Nutritionix provides base nutritional values per default serving (e.g., per 1 cup or per 100g). When a user adjusts the serving quantity, you must proportionally scale all macros. For example, if a food has 200 calories per 100g and the user logs 150g, the actual logged calories will be 200 * (150\/100) = 300 calories. Implement a helper function that takes the base nutrition, the base serving weight, and the user\u2019s desired serving weight, and returns the adjusted values. You should also allow the user to log the same food multiple times (e.g., two servings of chicken) by increasing the <code>servingQty<\/code> field. Storing the base nutrition along with the scaled quantity ensures that if the user later edits the entry, you can recalculate accurately.<\/p>\n<p>To provide visual feedback, create a progress bar component that receives the current total calories and the daily goal. Use a simple <code>View<\/code> with a dynamic width proportional to the percentage achieved. Change the bar\u2019s color based on thresholds: green for <75%, orange for 75\u2011100%, and red for >100%. Also display remaining calories: \u201cYou have 500 calories left\u201d if under goal, or \u201cYou are 200 calories over\u201d if exceeded. Additionally, show a breakdown per meal by grouping entries by <code>mealType<\/code>. This gives the user insight into where their calories are coming from and helps them make better choices for future meals.<\/p>\n<h2>Step 7: Adding Data Visualization and Progress Tracking<\/h2>\n<p>Seeing trends over days and weeks is a powerful motivator. A calorie tracker should not only show today\u2019s data but also historical progress. Implement a History screen that displays a list of past days with their total calorie intake, and optionally a bar chart comparing each day\u2019s intake against the goal. Use the <code>react-native-chart-kit<\/code> library to render a bar chart on the screen. For this, query all food entries for the user for the last 7 or 30 days. Group the entries by date and sum calories for each day. Then pass the resulting arrays (labels: dates, data: calorie totals) to the <code>BarChart<\/code> component. You can also add a horizontal line representing the daily goal, so users can quickly see which days they exceeded or stayed under.<\/p>\n<p>To enhance the user experience, consider adding a weekly summary card that shows average daily intake, highest calorie day, and lowest calorie day. This can be calculated from the same grouped data. You might also want to include a simple line chart for macronutrient trends (protein, carbs, fat) to help users with specific goals like high protein intake. However, be careful not to overwhelm the user with too many charts at once. Start with a single bar chart for total calories and add options to toggle additional views. Also, ensure that the History screen refreshes when new data is added \u2013 using Firestore snapshot listeners will automatically update the chart as new logs are saved. For performance, consider batching the Firestore query over several days or limiting the chart to the last seven days on initial load with a \u201cLoad More\u201d button for older data.<\/p>\n<h2>Tips and Best Practices<\/h2>\n<h3>1. Implement Offline Caching for Seamless Usage<\/h3>\n<p>A calorie tracker is most useful when it works everywhere, including on the subway or in areas with spotty connectivity. React Native\u2019s <code>AsyncStorage<\/code> (or the newer <code>@react-native-async-storage\/async-storage<\/code>) can be used to cache the user\u2019s daily entries locally. When the app launches, load the cached version first and display it, then silently fetch the latest from Firestore in the background. For the food search, cache the last 50\u2011100 search results to avoid repeated API calls. You can also store the user\u2019s daily goal locally to reduce read operations. However, be careful about synchronization: if the user logs an entry while offline, store it locally with a pending flag, and push it to Firestore when connectivity is restored using a network listener.<\/p>\n<h3>2. Debounce the Search Input to Reduce API Calls<\/h3>\n<p>The Nutritionix API (and most external APIs) charges based on the number of requests or has rate limits. To avoid hitting these limits and to provide a smooth autocomplete experience, implement a debounce function on the search text input. Use a timeout of 300\u2011500 milliseconds after the user stops typing before sending the API request. Additionally, show a loading indicator during the search and consider caching the top results for common queries like \u201cchicken,\u201d \u201crice,\u201d or \u201capple.\u201d A simple implementation using <code>useRef<\/code> and <code>useEffect<\/code> can cancel the previous timeout when new text is entered.<\/p>\n<h3>3. Validate Nutritional Data for Consistency<\/h3>\n<p>When users manually enter foods or when data comes from the API, you may encounter missing or inconsistent values. For example, Nutritionix might return zero for some nutrients if the food is not fully analyzed. To handle this, define validation rules: if calories are missing or zero, show a warning to the user and require them to enter at least an estimated value. You can also build a fallback where you calculate calories based on macros (protein*4 + carbs*4 + fat*9) if the API does not return a direct calorie field. Always inform the user about possible inaccuracies and allow them to override the data. This builds trust and ensures your app remains useful despite data gaps.<\/p>\n<h2>FAQ Section<\/h2>\n<h3>Q1: How do I get accurate calorie data for the foods users search?<\/h3>\n<p>Using a reputable API like Nutritionix or Edamam is the most reliable way. These APIs curate data from government databases (e.g., USDA) and branded foods from manufacturers. However, no database is 100% accurate for every food, especially restaurant dishes or homemade recipes. To improve accuracy, allow users to create custom foods with their own nutritional values, and consider incorporating a barcode scanning feature that looks up products by UPC code. Additionally, you can implement a feature where users can correct data and submit it for review, though moderation is complex for a solo developer.<\/p>\n<h3>Q2: Can I use the app without an internet connection?<\/h3>\n<p>Yes, with proper offline caching. As mentioned in the tips, store the user\u2019s daily entries, recent searches, and their calorie goal locally using AsyncStorage or SQLite. The app should function in read mode offline \u2013 the user can view their current day\u2019s log and past cached days. Logging new entries offline will require a mechanism to queue them and upload when connectivity returns. Services like Firebase\u2019s offline persistence for Firestore (when using the native SDK) can handle this automatically, but with Expo you may need to implement it manually. For a minimal viable product, you can restrict the app to online\u2011only initially and add offline support in a later iteration.<\/p>\n<h3>Q3: How should I handle different units (grams, ounces, cups) when logging food?<\/h3>\n<p>Normalize all serving sizes to a standard weight, ideally grams, for backend storage. When the user selects a serving unit (e.g., \u201c1 cup\u201d), convert it to grams using a predefined conversion factor (e.g., 1 cup of water = 240g, but for other foods the density varies). A simpler approach is to display the serving size as provided by the API and allow the user to adjust the quantity as a multiplier. For example, if the API says \u201c1 cup (240g)\u201d and the user logs 2 cups, store the quantity as 2 and the base serving weight as 240g. Then calculate calories as <code>baseCalories * (userQuantity \/ baseQuantity)<\/code>. This avoids needing a full conversion table. Be transparent with the user about the serving unit displayed.<\/p>\n<h3>Q4: How can I allow users to create and save custom foods?<\/h3>\n<p>Create a dedicated screen with input fields for food name, serving size (grams or cups), and the macronutrients per serving (calories, protein, carbs, fat). When the user saves, write a document to a subcollection called <code>customFoods<\/code> under the user\u2019s Firestore document. Each custom food should be given a unique ID and stored with the user\u2019s UID, so only that user can see and use it. To differentiate custom foods from API foods in the search results, you can merge the custom foods list into the search results with a label like \u201c(Custom)\u201d beside the name. Additionally, allow users to edit or delete their custom foods from a settings screen.<\/p>\n<h3>Q5: How do I sync data across multiple devices for the same user?<\/h3>\n<p>Since you are using Firebase Firestore as your backend, syncing across devices is inherent to the database design. All data is stored in the cloud, and any device the user signs into with the same account will have access to the same data. Firebase\u2019s real\u2011time listeners automatically push updates to all connected clients. However, ensure you handle conflicts gracefully: if a user logs an entry on two devices simultaneously, Firestore uses a \u201clast write wins\u201d strategy, which is acceptable for a calorie tracker. For offline scenarios, the local cache will be synchronized when the device goes online. Provide a \u201csync now\u201d button in settings for manual reassurance, and always display the last synced timestamp to the user.<\/p>\n<h2>Conclusion<\/h2>\n<p>Building a calorie tracker app from scratch is a challenging but highly rewarding project that touches nearly every aspect of full\u2011stack mobile development. You have learned how to plan core features, set up a cross\u2011platform development environment with React Native and Expo, integrate Firebase Authentication and Firestore, connect to the Nutritionix API for real food data, implement logging and daily aggregation logic, and present progress with intuitive charts. Along the way, we explored best practices like offline caching, debouncing API calls, and data validation to create a robust user experience. The resulting app is a functional MVP that you can further enhance with barcode scanning, recipe builder, social sharing, or even machine learning for meal photo recognition. The next steps involve testing on real devices, polishing the UI, and submitting to the App Store and Google Play. Remember that the key to a successful health app is simplicity and reliability \u2013 users should be able to log their meal in under ten seconds. With the foundation laid in this guide, you are well on your way to launching a calorie tracker that people will genuinely enjoy using every day. Now open your code editor and start building!<\/p>\n","protected":false},"excerpt":{"rendered":"<p>The Ultimate Guide to Building a Fully Functional Calorie Tracker App from Scratch In today\u2019s health-conscious world, tracking daily calorie intake has become a cornerstone of weight management, athletic performance, and general wellness. Building your own calorie tracker app not only gives you complete control over your data, but it also provides a deep learning &hellip; <\/p>\n","protected":false},"author":2716,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"footnotes":""},"categories":[],"tags":[],"class_list":["post-1146","post","type-post","status-publish","format-standard","hentry"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/posts\/1146","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/users\/2716"}],"replies":[{"embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/comments?post=1146"}],"version-history":[{"count":0,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/posts\/1146\/revisions"}],"wp:attachment":[{"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/media?parent=1146"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/categories?post=1146"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/sumberlaba.com\/index.php\/wp-json\/wp\/v2\/tags?post=1146"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}