id
stringlengths 14
14
| text
stringlengths 109
4.45k
| source
stringlengths 22
132
|
|---|---|---|
cfcd208495d5-0 | No Code Backend Development Platform Xano is the fastest way to build a powerful, scalable backend for your app without code. Xano gives you a scalable server, a flexible database, and a NO CODE API builder that can transform, filter, and integrate with data from anywhere. We want to enable you to validate AND grow your ideas quickly without limits or any of the barriers you might have encountered using other tools. 💪 New to Xano? 🤷 I'm a Complete Beginner and need to learn about the Backend. ⚡ I've got Intermediate API knowledge and am ready to build my backend from scratch. 🔌 I know what I'm doing. Teach me how your NO CODE API Builder works. Building your backend and need help? Database Basics Field Types Relationships Importing Data The API Basics NO CODE API Builder Testing your API Connecting to a Front-End External API Requests Webhooks API Request History Transforming Data Basics Functions (Actions) Filters (Transformations on Existing Data) Addons (GraphQL-like) (Enriching Data) Working with Dates & Time Re-sizing Images Background Tasks (Cron Jobs) Next Release notes Last modified 1yr ago | https://docs.xano.com/ |
c4ca4238a0b9-0 | Low level details on each Xano release The Xano release notes have been moved to their own space.
👇🏻 Xano Release Notes Previous Welcome Next Roadmap & Requests Last modified 9mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/release-notes |
c81e728d9d4c-0 | What do you want to see the Xano team work on next The Xano team launches new releases on a weekly basis and many of the features are driven by customer demand. If you'd like to vote on what we work on next, Check out our feedback board below: 👇🏻 Xano's Feature Request Board Previous Release notes Next Frequently Asked Questions Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/roadmap-and-requests |
eccbc87e4b5c-0 | Xano FAQ Table of Contents Scaling & Performance Front-end Data API Code Marketplace Pricing Agencies Custom Development Hosting Scaling & Performance What are Xano's limits?
When it comes to building the backend for your application, building to 95% capability isn't good enough.
You need a platform that can handle every edge case you throw at it and Xano is that platform.
From its inception, it was built to be the first Turing complete NO CODE backend so anything you can do in a regular programming language (PHP, C, Javascript, etc.)
you would be able to do in Xano.
Can I scale my backend with Xano?
Yes.
With Xano you don't need a DevOps team because we handle everything for you.
Docker and Kubernetes are used to provision new accounts which provides a stable, scalable environment on top of Google Cloud and the PostgreSQL database offers not only the power and flexibility of SQL/NOSQL, but can scale horizontally and vertically.
What happens to my backend if Xano shuts down?
We want each one of our users to feel secure in building their businesses and backends on the Xano platform, so in the very unlikely scenario that we decide to close up shop, Xano would either open source or grant a perpetual license to the software - it would need to be migrated to your own hosting, but there would be a path to do so.
What if I need more capacity outside my plan?
We've structured our Launch & Scale plans to be optimized for the products we see most often.
However, if you should need more capacity outside of our Business plan, whether it be file storage, workspaces, team seats or bandwidth, we have pricing and you can contact sales.
Does Xano rate limit?
Only the Build (Free) plan has a rate limit.
Any paid instance does not have rate limiting.
For more information on the specifics please visit xano.com/pricing.
Front-End Can Xano build my front-end?
No.
Xano only handles your entire backend, which consists of development, dev-ops, database & APIs as a hosted platform.
It does not create any sort of front-end for your project.
You can take the API endpoints you create in Xano and link them to the front end of your choice or with one of our preferred front end solution providers Does Xano work with other No Code front-end tools?
Absolutely.
We built Xano with the idea that it would seamlessly integrate with other popular and up and coming No Code tools.
Please visit Connect to a Front-End for more information.
Data Who owns my data?
You own your data.
This also include any data that your users might upload unless your agreement with them specifies otherwise.
Can I move my backend code off Xano?
No.
Since Xano's system creates and hosts all your project backend development code with a simplified NO CODE methodology, moving your business logic can potentially break and render your project inoperable.
However, we are investigating ways to make this work as a future enterprise option.
Can I export my data?
Yes.
You can export your data through the settings in your instance.
The data will be exported as a .YAML file format.
Can I import my data to Xano?
Yes, Xano has a robust and powerful CSV import that is capable of importing millions of records.
Additionally, Xano has a native Airtable import if you wish to bring your Airtable data into Xano.
Other methods can be accomplished through the No Code API Builder.
Can I migrate my backend from another BaaS (Backend as a Service) provider?
We currently do not have a way to import or migrate a backend from another provider.
This is largely because the infrastructure and format can drastically differ.
We plan to look into certain functionalities if it makes sense as we see what customers want.
Can I copy and paste my data into the database?
Currently, no. | https://docs.xano.com/faq |
eccbc87e4b5c-1 | However, we are aware that this is a popular request and it's on our roadmap.
How does Xano handle backups?
On any of our paid plans, Xano maintains full backups of your server instance on a rolling 3 day cycle.
We take backups every 24 hours.
These can be restored by submitting a request to support.
At this time, only whole-instance restore is available, though more granular restore is on our roadmap.
API Can I make an External API request in Xano?
Yes.
You can access and process an external API Endpoint with Xano.
This can be found within the Function Stack.
How do I schedule a recurring API request?
Tasks (or Background Tasks) allow you to utilize scheduling capabilities - both recurring and one-off.
Tasks are only available on paid instances.
How can I extend data from multiple sources in a single API request?
Addons allow you to extend data from multiple sources in a single API request.
Addons give you complete control over how your data is queried.
Please visit the Addons page and guide for more information.
Does Xano provide documentation for my API Endpoints?
Yes.
Xano automatically generates documentation for your API Endpoints using Swagger.
You can find this on the API page > API Documentation.
Additionally, there is a link to it on the right side of the page within an API group.
Code Can I see the code that my Xano backend is being hosted on?
No.
Xano prides itself in being a No Code or Zero Code solution.
We enable both technical and non-technical users alike to build their backends without code or compromise.
In doing so, we allow our users to save weeks to months of time in development and up to hundreds of thousands of dollars in costs.
To stay true to our No Code DNA we do not provide the code at this time.
Marketplace Will the Marketplace have templates that I can use to start my backend with?
Yes.
Although the Marketplace was just launched, we are very excited to begin releasing templates for our users to use for their projects.
We have many useful and exciting templates on our roadmap.
Can I develop an extension or template and sell it on the Xano Marketplace?
You are able to develop Snippets to share API endpoints and examples with other users.
Allowing our users to develop extensions and templates for the Marketplace is on the roadmap.
Stay tuned for more information.
Pricing How much will Xano cost and how do I upgrade?
Pricing depends on which plan you choose.
For detailed information on the cost of each plan and what is included please visit xano.com/pricing.
In order to upgrade, please visit the Billing page in your Xano account and select "Change Plan."
Account Can I put a hold on or pause my account?
If you need to put a hold on things by cancelling your subscription and wish to come back later, Xano can preserve your data for up to 60 days from the end of your subscription.
You must contact support to do so.
After you cancel, you will not be able to access your instance.
When you are ready to come back you must contact support again and re-initiate payment on your subscription to access your instance.
After the 60 day grace period your data and workspace could be lost and you may have to start over from scratch.
Can I get a refund on my paid plan?
Xano does not allow refunds of any kind on its monthly paid plans.
You can choose to cancel your subscription at any time from the Billing page.
Cancelling your account will result in loss of workspaces, live API endpoints, and all data.
If you purchase an annual plan and need to cancel within the first month, you can receive a refund minus the monthly rate.
You must contact support to do so.
After the first month, no refunds can be given.
Compliance Can I satisfy HIPAA Compliance while using Xano as my Backend?
Yes. | https://docs.xano.com/faq |
eccbc87e4b5c-2 | Xano can be used to build HIPAA-compliant applications.
HIPAA compliance, including a signed BAA for your entity, is an upgrade to any paid plan or comes included with an Enterprise plan.
With this upgrade, your server is migrated to a hardened location for enhanced security.
Read more about HIPAA compliance Is Xano GDPR Compliant?
Yes.
Xano can meet GDPR compliance and will issue a DPA for any Scale, Agency or Enterprise plan.
Read more about GDPR compliance It's worth noting that as a backend, we are much less at risk than a tool that is allowing users to build the front-end.
Ultimately, much of the responsibility is on the user that is building and their setup in store customer information.
That said, Data security is paramount to us, which is why in addition to GDPR Xano holds a certification for ISO 27001:2013.
Agencies Does Xano work with Dev Shops / Agencies?
Xano's origin was spawned via a development shop.
So we know what they want with regards to client projects.
Our objective is to simplify the backend development process while saving tons of money and time to complete each project.
We also have a plan specifically tailored towards this use case, so check out the Xano Agency Plan.
Can I collaborate with others on a project in Xano?
Yes.
Development can work better if a team is involved.
Depending on which package you're subscribed to, you can grant access to other teammates to your instance and work on a project together.
Custom Development Can I create a custom plan with Xano?
Yes.
This can be done by contacting us and inquiring about our custom enterprise setup.
Can I hire a Xano expert to help develop my custom backend?
Yes.
Please fill out this form and a Xano representative will get back to you in 24 hours.
What to expect once you engage with an expert: Discovery: The Xano expert needs to understand your business goals.
Mapping: Construct a framework of how your backend maps to your business.
Database Modeling: Build the database schema that houses your data.
Configure APIs: Create all the business logic required to send and receive information from your database.
Documentation: Ensure API documentation is ready to be handed off to a front-end engineer or for you to test and configure with any no code front-end tool.
Testing: Access backend build-out with you and / or your team.
Hosting How and where is Xano Hosted You can read more about the Technology we use to host your scalable backend.
Can I host Xano "on-premise?"
Typically...no.
However, this can be done with an Enterprise setup.
Contact us today to inquire.
Previous Roadmap & Requests Next What is Xano?
Last modified 3mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/faq |
a87ff679a2f3-0 | No Code Backend Development Platform Xano is the fastest way to build a powerful, scalable backend for your app without code. Xano gives you a scalable server, a flexible database, and a NO CODE API builder that can transform, filter, and integrate with data from anywhere. We want to enable you to validate AND grow your ideas quickly without limits or any of the barriers you might have encountered using other tools. 💪
Link to YouTube Video: https://www.youtube.com/watch?v=ng0GiVYOFnc What's Next? 🤷 I'm a Complete Beginner and need to learn about the Backend. ⚡ I've got Intermediate API knowledge and am ready to build my backend from scratch. 🔌 I know what I'm doing. Teach me how your NO CODE API Builder works. Previous Frequently Asked Questions Next What's included Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/about |
e4da3b7fbbce-0 | Each Xano account comes with the following An Instance - This is the server that powers your app
You can think of an Instance like a server where your backend is hosted. The performance of each instance is dictated by the subscription plan that you have. Each account has one instance but you can add more or share your instance with others. A Workspace - A container for your app/project
Workspaces live inside an instance and you can think of them like projects folders. They are unique containers for your app that come with their own unique Database and API. Depending on your plan, you can have multiple workspaces on the same instance and they'll all share that instance's resources.
Each Workspace includes a unique: Database - The heart of your application where all your data lives. API - The messenger that runs commands to/from your database to your front-end. Xano gives you a NO CODE API builder to make creating API Endpoints a breeze. Previous What is Xano? Next Server Instance Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/what-xano-includes |
1679091c5a88-0 | In Xano, an Instance is a server where your Workspaces are hosted. The performance of each instance is dictated by the subscription plan that you have. Each account has one instance but you can add more or share your instance with others.
Link to YouTube Video: https://www.youtube.com/watch?v=kZZ3S3OzNeM Types of Instances Shared Instances Free (Explore plan) accounts
Free accounts come with one workspace that shares resources with others Xano customers. It also is limited on capabilities such as storage, database records, and processing power. You'll easily be able to prototype most of your application in this type of account, but upgrading to a paid plan will give you a more powerful instance that features the following: Dedicated Instances Launch Plan Dedicated server resources No Rate limiting Unlimited record capacity Video and file attachments Version history 5 background tasks Region-specific servers Australia (Sydney) Brazil (Sao Paulo) Canada (Montréal) Germany (Frankfurt) India (Mumbai) Singapore USA (Oregon) UK (London) Scale plans Multiple workspaces Dedicated server resources Teammate collaboration Data test environment API versioning via branches 15 Background tasks Version history No Rate limiting Region-specific servers Australia (Sydney) Brazil (Sao Paulo) Canada (Montréal) Germany (Frankfurt) India (Mumbai) Singapore USA (Oregon) UK (London) Custom Domains How can I upgrade?
Go to the Billing section within Xano. You can get there by clicking "Billing" in the side menu on the instances page or by clicking your initials when you're in your workspace and clicking the "Billing" link. Previous What's included Next Your Xano Workspace Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/what-xano-includes/instance |
8f14e45fceea-0 | Link to YouTube Video: https://www.youtube.com/watch?v=eMVIRer4LaQ When you create a Xano account, you're given a server Instance where a Workspace is hosted. Think of a Workspace like a unique container for your application. While they share resources with other Workspaces in your Instance, they have their own unique database and structure to them. The number of workspaces vary according to your subscription plan. There are three main components you should understand The Dashboard
Information about how to Use Xano effectively as well as Workspace usage stats. The Database
The heart of your application where all your data lives. The API
The messenger that grabs data from the database (or any external API) and presents it to your front-end in a way that you choose. Previous Server Instance Next Dashboard Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/what-xano-includes/workspace |
c9f0f895fb98-0 | The dashboard is where you can find valuable resources to help improve your usage of Xano. The Dashboard is the Home to your Workspace that provides status and guides to help you become successful with Xano. Quick Start Guide
This widget has curated educational videos and tasks to help you on your journey in building a backend. We highly recommend that you go through it! Quick Links
A collection of links and resources where you can get answers and learn about how to build your back-end properly. Workspace Usage
We'll be adding dashboard widgets to tell you what your usage patterns are in your Workspace. The Database table one is our first. Previous Your Xano Workspace Next Marketplace Last modified 4mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/what-xano-includes/workspace/dashboard |
45c48cce2e2d-0 | A place for templates and plugins that can be added to your Workspace. The Marketplace provides an area where you can easily install capabilities that extend your Xano Backend. Extensions
You can think of Extensions like capabilities that you can add to your App. "Send SMS" might be an extension that you install that uses the service Twilio to send a text message to your users. Starter Templates
Starter templates are fully-functional backends that you can install and build on top of. They include things like ready-to-use database tables, API endpoints and functions. Previous Dashboard Next Library Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/what-xano-includes/workspace/marketplace |
d3d9446802a4-0 | The Library contains re-usable elements (Functions, Background Tasks and Addons) The Library contains re-usable elements divided into three buckets: Functions This section contains Custom Functions that are either created by you, or by one of the Marketplace extensions you install. Addons Contains Addons that you've either used in one of your API Endpoints or one pre-installed from the Marketplace or Snippets. Files This section is a file management interface enabling you to manage all the files associated with your workspace. Tasks (Cron Jobs) Background Tasks (or Cron Jobs) are functions that can run behind the scenes at an interval you specify. This section contains all of your active/inactive Tasks. Previous Marketplace Next PostgreSQL Database Last modified 4mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/what-xano-includes/workspace/library |
6512bd43d9ca-0 | The database is an organized collection of data, stored in a group of tables. Xano hosts your data on a PostgreSQL database which is the most powerful open source database in the world. It provides the flexibility of a relational database along with the Big data needs of a NoSQL solution. PostgreSQL is a powerful, open source object-relational database system that uses and extends the SQL language combined with many features that safely store and scale the most complicated data workloads. The origins of PostgreSQL date back to 1986 as part of the POSTGRES project at the University of California at Berkeley and has more than 30 years of active development on the core platform.
Link to YouTube Video: https://www.youtube.com/watch?v=hsrjGXz4-q8&feature=youtu.be Learn more about the Database Previous Library Next Settings Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/what-xano-includes/workspace/database |
c20ad4d76fe9-0 | The settings is a control panel for your Workspace. The settings page serves as a control panel for your workspace. You can change your Workspace name, set Environment Variables, export your data, and clone, reset, or delete your Workspace. The menu icon in the upper right-hand corner of the settings page gives you access to the various actions you can do to your workspace. Select the menu icon to perform an action to your workspace Settings - Allows you to change the name and add a description for your Workspace. Clone Workspace - Will copy all database table schema, API groups, API queries, functions, Addons, and backgrounds tasks into another workspace. It will not copy the database table records. Export All Data - Enables you to export all the data from your Workspace in a .YAML file. This could take a few minutes depending on how much data is contained in your Workspace. Reset/Delete - If you are on the Free plan, you can reset your Workspace if you wish to start over. If you are on a paid plan, you can delete your Workspace. Previous PostgreSQL Database Next Environment Variables Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/what-xano-includes/workspace/settings |
c51ce410c124-0 | These are accessible throughout your Queries, Addons, Functions, and Tasks. Environment Variables are a great place to store private information like API keys in a single location. Environment Variables are Variables that can be used by multiple APIs or Functions. They are set up on the settings page of your Workspace. $remote_ip:
This is a special environment variable that resolves to the IP address of the individual accessing the API Endpoint. $http_headers:
This is a text Array of headers that are sent to the API Endpoint. $request_uri:
Returns the request URI. $request_querystring:
Returns the query string from the request. $datasource:
Returns the active data source being used for database queries. https headers:
https headers are what is sent to the API. There is no pre-populated list because it depends on what is sent. But you can add the headers to the response to see what is being sent: In this example, we are returning the Environment variable $http_headers. In this example, we can see the headers being sent to the API through the response. We can use dot notation to use or return a specific header: In this example, we are using dot notation to return the header X-Request-Id The result, as shown in Swagger, is the value of the X-Request-Id header. Previous Settings Next API Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/what-xano-includes/workspace/settings/environment-variables |
aab3238922bc-0 | The API, or Application Programming Interface, defines how data is exchanged between your database and any software that needs access to it. You can think of the API like a messenger that runs back and forth between your database and other services to collect information and eventually pass it to the front-end.
Link to YouTube Video: https://www.youtube.com/watch?v=xxRqUuft324&feature=youtu.be Learn more about the API API Basics Previous Environment Variables Next Managing your Backend with 'Referenced By' Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/what-xano-includes/workspace/api |
9bf31c7ff062-0 | Using the 'referenced by' feature
Link to YouTube Video: https://www.youtube.com/watch?v=8M3ZPWebC28 https://www.youtube.com/watch?v=8M3ZPWebC28While building your application in Xano, as your arsenal of tables, API endpoints, functions, addons, and background tasks grows, you can use Xano's Referenced By feature to quickly jump to related elements in your instance. This is especially helpful when performing maintenance tasks like cleaning up unused functions. You can quickly see where that function is used before deleting. Where can I use Referenced By? Referenced By is available when working almost anywhere in Xano, including... Database tables API endpoints Functions Addons Examples Let's say that you are working inside of a database table, and you want to quickly see all of the function stacks that utilize that table's data. This will show API endpoints, functions, addons, and background tasks, which you can quickly navigate to from the modal. Showing the location of Referenced By in a database table Displaying all of the APIs that reference this table Alternatively, you could be working inside of a custom function and want to quickly see every API endpoint that it is called by. You can click the blue text to show the Referenced By modal for that function. This is also available while working inside of the custom function. A similar view is available inside of an Addon. Previous API Next Technology Last modified 9mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/what-xano-includes/workspace/managing-your-backend-with-referenced-by |
c74d97b01eae-0 | With Xano you don’t need a DevOps or Backend engineering team because we handle everything for you. Docker and Kubernetes are used to provision new accounts which provides a stable, scalable environment on top of Google Cloud and the PostgreSQL database offers not only the power and flexibility of SQL/NoSQL, but can scale horizontally and vertically. Here are some features you can enjoy using Xano Fully Hosted Xano is a fully hosted solution without any modules or SDKs to download. Just point and click on our secure platform. Region-Specific On our Launch and Scale plans, you're able to select the regions where your Instances are hosted. Currently, we support these regions: Brazil (Sao Paulo) Canada (Montréal) Germany (Frankfurt) India (Mumbai) Singapore UK (London) Scalability & Orchestration Xano uses Docker containers to provision new accounts and Kubernetes to scale. This provides a stable environment for each user to build and scale their service without compromise. Flexible Xano utilizes PostgreSQL, which is the most powerful and flexible database within the open-source community. It provides the flexibility of a relational database along with the Big data needs of a NoSQL solution. APIs Documented automagically API Endpoints are automatically documented for you in OpenAPI (Swagger). CRUD made easy Xano makes it easy to generate basic CRUD operations and keeps the model in sync with the endpoint. Backend templates Get started right away with most of the work done for you. Add capabilities to your Xano application in a few clicks. These starter templates are complete workspaces that come with their own database, functions and API endpoints. Use these as a starting point to build the rest of your backend. Rapid development Rapidly get your company backend built with our no-code platform. Real-time application backend development with customized workflows and functionality. SSL certificates Xano makes it easy to scale your project and keep your instance safe with SSL certificates included. Function stack Visualize the components of your backend in an easy-to-understand flow diagram! Learn more. Input & Output mapping Secure, easy-to-use, code-free customizable metadata management & mapping. Precondition logic Make sure your application runs exactly how you want it by enforcing preconditions before anything important is processed. Function operations Repackage common operations (send mail, send SMS, etc.) into functions that can be reused throughout your project. Recursive functions Create complex error-free recursive functions with no code! Previous Managing your Backend with 'Referenced By' Next Docker Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/technology |
70efdf2ec9b0-0 | Application Containerization Docker is a tool designed to make it easier to create, deploy, and run applications by using containers. Containers allow a developer to package up an application with all of the parts it needs, such as libraries and other dependencies, and ship it all out as one package. Xano leverages Docker containers. Docker’s virtualization technology provides Xano the capability of running the components (PostgreSQL, PHP, Redis, etc.) in the same environment each and every time. This allows a consistent environment for development, testing, and production because the technology runs inside the Docker Engine instead of on the server. Previous Technology Next Kubernetes Last modified 2yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/technology/docker |
6f4922f45568-0 | Application Scalability Kubernetes is a solution by Google for automating application deployment, scaling, and management. Xano leverages Kubernetes to manage the entire release cycle of all the Docker containers. Kubernetes is constantly monitoring the environment and has the ability to auto-scale based on a variety of environmental factors.
Here’s how Kubernetes fits into a typical software development environment: Previous Docker Next PostgreSQL Last modified 2yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/technology/kubernetes |
1f0e3dad9990-0 | The World's Most Advanced Open Source Relational Database PostgreSQL is a powerful, open-source object-relational database system with over 30 years of active development that has earned it a strong reputation for reliability, feature robustness, and performance. We take databases seriously! That is why every project built in Xano utilizes PostgreSQL so that you do not need worry about power and flexibility. Here are few notable companies that currently utilize PostgreSQL. Apple Bloomberg Disqus IMDB Instagram International Space Station Northrop Grumman Reddit Runkeeper Skype Spotify Sony Online TripAdvisor Twitch Previous Kubernetes Next What is a Backend? Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/technology/postgresql |
98f137082101-0 | A Backend typically consists of a server that powers your content, a database that stores your content, and an API that serves the content to and from the front-end. Understand how the backend works by watching this quick explainer video.
Link to YouTube Video: https://www.youtube.com/watch?v=g2f6zuDsw-Y Previous PostgreSQL Next Why have a separate Backend? Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/what-is-a-backend |
3c59dc048e88-0 | Why use a separate NO CODE backend like Xano instead of an all-in-one solution? We often get asked by the NO CODE community why it makes sense to have a separate backend when you could use an all-in-one solution like Bubble or another tool with internal collections. Here are a few reasons why it makes sense. Here's a clip of our Co-founder Prakash talking about it during a NO CODE Fellowship
Link to YouTube Video: https://www.youtube.com/watch?v=zCVPGg2vJfE 1. One Backend can power many front-ends
While you might start out with just a web application in something like Bubble, over time the data from your backend will likely need to be shared across many different front-ends. This might include a native mobile application built in another tool, an admin dashboard for user management, and much more. Having a single powerful backend that can feed into different front-ends puts you at an advantage as your company scales. 2. Co-Development made easy
When working in an all-in-one tool, you typically have to mix backend and front-end workflows/logic, which can get confusing as your app grows. This especially becomes messy when you are working with more than one person. When you have a separate backend, there is a clear separation around where all the business logic is handled. 3. Transform and Store Data
Xano specializes in taking data from multiple sources and giving you the power to transform it to your needs. This becomes important when you start talking to other APIs and services which give you data in different formats. 4. 100% focused on the Backend. Built for Scale
Xano is 100% focused on being the best NO CODE Backend on the market and isn't distracted by the complexities that working in the front-end can bring. This allows us to not only give you the most comprehensive set of features but an infrastructure that was built from the ground up that ensures your app can scale to the moon. Previous What is a Backend? Next - Fundamentals Getting Started with Xano Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/why-have-a-separate-backend |
b6d767d2f8ed-0 | When you create an account with Xano, you're taken through a wizard called Jumpstart. It asks you to specify a few things about your project and allows Xano to automatically create a backend to get you started. 💪 Setting up your Workspace After you create an account and your Instance, your next step should be to create a Workspace. On the first page of Jumpstart, We'll ask you a bit about yourself so we can tailor the Xano experience to you. This will affect what videos and tutorials we show you. Your work space is like a container for your project or app. Name it accordingly Pick how you want to get started Start from scratch - Define database tables based on the app you are planning on building. We'll handle generating the CRUD (Create Read Update Delete) API Endpoints for you. Import from Airtable - Sync your bases, relationships and content. (learn more) Start with a template - We've created pre-made Backend templates which include database tables, API endpoints and dummy content. Starting from scratch You can add as many tables as you want and even remove the user table if your app doesn't have users.
There is the option to add CRUD endpoints for each table which are APIs that allow you to Create, Read, Update, and Delete records from your Database. Enter your Database tables names and choose if you want CRUD endpoints automatically generated for each table. Pre-install App Extensions (Features) Xano can pre-install a few extensions which do the heavy lifting of implementing things like payments, SMS messaging and more. Once you install an extension in a Workspace you'll need to set it up using the instructions on your dashboard. Usually this involves entering your unique API key from the service being installed. Add Authentication to your app: Authentication is the process that allows your users to sign up and log in to your app. Xano comes equipped with Authentication tools that you can turn on here. We offer the ability to authenticate via Email (using JWE tokens) and other options will be presented below. Selecting another OAuth provider like Google/Facebook will require configuration after your Workspace is created. Just hit Finish and your Workspace is created. All of the Database tables will be created and all of the C.R.U.D. APIs will be created for each table. If you chose to add Authentication these endpoints will show up in your API groups. Previous Why have a separate Backend? Next - Fundamentals The Development Life Cycle Last modified 4mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/fundamentals/getting-started |
37693cfc7480-0 | There are Six Phases to the Software Development Life Cycle (SDLC), and Xano is designed to support you and your team through each one.
Before you start building, we wanted to share some best practices around how to think about creating your product or service.
If you don't need to learn this, you can go straight to setting up your Database.
When you have an idea for an app or a project that you'd like to build, it's easy to feel overwhelmed and not even know where to begin.
Regardless of whether you're on your own or with a team, it's important to have a framework around how you approach designing, launching, and maintaining your application.
Luckily, when building in Xano, you can leverage a tried and tested methodology called the Software Development Life Cycle (SDLC).
There are Six Phases to the Software Development Life cycle, and Xano was designed to support you and your team through each one.
1.
Planning/Analysis The first stage of the SLDC usually consists of two parts which start with gathering requirements from your customers or relevant stakeholders, ensuring you are solving a real problem, then analyzing the feasibility of creating the product, revenue potential, cost, and more.
Once you decide what you're building is in line with stakeholder goals, addresses user needs, and is feasible to create, you can move to the second stage.
2.
Design The design phase is where you start to put your ideas to paper.
This might include creating actual designs in a tool like Figma, or going higher level and using a tool like Miro to create a wireframe or flowchart.
From a Xano perspective, this is where you would start designing a data model (video tutorial).
3.
Development With a solid foundation to work with, this phase is where the actual development happens and where you turn specifications and designs into an actual product.
This phase usually takes the most time, so setting expectations with yourself and the stakeholders you are working with is important.
Xano helps accelerate this stage with features like: Generation of API CRUD Operations Auto-Documentation Real-time Collaboration If you're working with a team, you can leverage Xano features like real-time collaboration to seamlessly work within the same workspace, or create Branches and Merge them in when you're ready to move to the testing phase.
4.
Testing Before launching any product or service, it's important to have everything tested.
At this phase, you would have a quality assurance (QA) team step in to run tests, but if you're on your own, you'll need to think through every part of testing your product which is more than just fixing critical bugs.
This might sound easier than it seems, but it's essential to test all the different permutations and ways that your users might interact with your application.
Here are some different types of testing that you can do in this phase.
Performance testing
Is your product ready to handle the traffic/storage requirements?
Functional testing
Does your application meet the requirements set for in the Planning/Analysis phase?
Security testing
Is your data in a secure place, and do you meet the appropriate compliance certifications within your country, or if you're dealing with sensitive data?
Unit testing
Does every part of your app work the way it's supposed to?
Usability testing
Do your users actually understand how to use your app?
Xano provides a few features to help you in this phase.
Using Data Sources can help you use dummy data without affecting what will be live in production.
Our API Builder supports Drafts to help you and your team get things right before Publishing.
Branches can be used to create separate testing environments (Development, Staging, Production).
For more complex use cases, Xano also supports Xano Link, which allows you to keep all of your Workspaces and Instances in sync with a master so your customers have a consistent experience.
5.
Deployment Now the fun begins. | https://docs.xano.com/fundamentals/the-development-life-cycle |
37693cfc7480-1 | The Deployment stage is where your product or service is shipped to its intended user(s).
This process can depend on the nature of what is being released; however, it's best practice to launch to a small set of users (typically called a canary release).
6.
Maintenance Maintenance is typically the last stage of the SDLC; however, in today's world, people are moving toward a more Agile software development approach where the product or service is continually improved, and sometimes the feedback from users makes it necessary to go back to the first step of the SDLC.
This is why most images of the SDLC that you find are circular because it is a process that keeps repeating itself once you find something that's working.
Fundamentals - Previous Getting Started with Xano Next - Fundamentals Designing your Database Last modified 3mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/fundamentals/the-development-life-cycle |
1ff1de774005-0 | The database is the heart of your application and it's important that you understand the ins and outs of how one works. From Idea to App - Designing and setting up your Database
Link to YouTube Video: https://www.youtube.com/watch?v=LZZYYYe5U9I Fundamentals - Previous The Development Life Cycle Next - Fundamentals Setting up your API Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/fundamentals/setting-up-your-database |
8e296a067a37-0 | What is an API? The API, or Application Programming Interface, defines how data is exchanged between your database and your front-end or any software that needs access to it. You can think of it as a messenger that runs back and forth between your database and other services to collect information and eventually pass it to the front-end.
Link to YouTube Video: https://www.youtube.com/watch?v=knWgT8oI1Qc Thinking about the API in the context of your App Idea Xano provides a NO CODE API builder that we cover in great detail, but this video gives you a quick overview of what to expect. This also lightly covers Database Relationships and Addons
Link to YouTube Video: https://www.youtube.com/watch?v=rITkRsaJ5jo CRUD (Create. Read. Update. Delete) API Endpoints Xano auto-generates and documents your basic CRUD API operations which make it easy to retrieve, send and delete data from your database. Of course, you can get as complex as you need to be in Xano but understanding the basics is essential. ▶️ Create (POST) operation ▶️ Read (READ) operation ▶️ Update (POST) operation ▶️ Delete (DEL) operation Building your own API Endpoints This section covered the basics of what an API is and the basic CRUD operations associated with it, head to the NO CODE API builder section for more detail on building your own. Fundamentals - Previous Designing your Database Next - Fundamentals Connecting to a Front-End Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/fundamentals/building-your-api |
4e732ced3463-0 | Connection to Xano is done through the API, which in Xano's case is a REST API - nearly all front-ends are able to ingest a RESTful APIs making Xano front-end agnostic.
Xano provides a documented robust backend that you can plug into any front-end of your choice.
Link to YouTube Video: https://www.youtube.com/watch?v=GSH0SqsEEE8 NO CODE Tools Adalo (see more on YouTube)
adalo.com
Link to YouTube Video: https://www.youtube.com/watch?v=6IUj2RKSS_M AppGyver
appgyver.com https://www.youtube.com/watch?v=x4lfENLp6YE www.youtube.com
Link to YouTube Video: https://www.youtube.com/watch?v=2KIoALcS4pY Appsmith
appsmith.com
Link to YouTube Video: https://www.youtube.com/watch?v=n3XSAA7q--I Bravo Studio
bravostudio.app
Link to YouTube Video: https://www.youtube.com/watch?v=KyycurC40bY
Link to YouTube Video: https://www.youtube.com/watch?v=fQ-pqFK2qkc
Link to YouTube Video: https://www.youtube.com/watch?v=b20hX_nI2Vs Bubble (see more on YouTube)
bubble.io
Link to YouTube Video: https://www.youtube.com/watch?v=aNB67Z92sZY
Link to YouTube Video: https://www.youtube.com/watch?v=G1l5P2FAtMk
Link to YouTube Video: https://www.youtube.com/watch?v=pwDOUbBI-v8 Clutch
Clutch.io Draftbit
Draftbit.com How to connect Xano to Draftbit (see more on docs.draftbit.com)
Link to YouTube Video: https://www.youtube.com/watch?v=zB_uGKRpP1Q
Link to YouTube Video: https://www.youtube.com/watch?v=8auUzFVfoi8 Retool
Retool.com
Link to YouTube Video: https://www.youtube.com/watch?v=N1bw5roQJzo Thunkable
Thunkable.com
Link to YouTube Video: https://www.youtube.com/watch?v=1baoj73frgE Webflow (see more on YouTube)
Webflow.com
Link to YouTube Video: https://www.youtube.com/watch?v=HMsrFzoZYr0 Webflow + Memberstack (see more on YouTube)
Webflow.com + Memberstack.com
Link to YouTube Video: https://www.youtube.com/watch?v=1cR3DofCuxY Others coming soon... Low Code Tools Low code tools are used by individuals that have a medium to expert level of coding experience.
You can greatly expedite the speed in which you build comprehensive applications using tools like the below.
React Studio
reactstudio.com React studio is an official Xano partner and they are the premium visual app design tool for the most advanced JavaScript UI library — React JS.
In the studio, you'll be able to easily Create app flows and components.
Express their properties and data linkage visually.
Get code immediately.
It also seamlessly integrates with Xano and you can see how to connect below.
Link to YouTube Video: https://www.youtube.com/watch?v=7AnXog2-ggY Front-end Frameworks Front-end frameworks Display an External API from Xano in Javascript This codepen serves as an example for displaying data from a Xano API in Javascript.
Of course, there are many different frameworks and potential ways to go about this.
Vue.js
vuejs.org Trevor walks us through how build a backend in Xano and connect it to Vue.js. | https://docs.xano.com/fundamentals/connect-to-a-front-end |
4e732ced3463-1 | Link to YouTube Video: https://www.youtube.com/watch?v=HH_RZhV9P-Q Gitlab repository of the working front-end:
https://gitlab.com/xano/trevor-sample Got more you're interested in seeing?
Let us know in the community Fundamentals - Previous Setting up your API Next Webflow Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/fundamentals/connect-to-a-front-end |
02e74f10e032-0 | Connect Xano to Webflow Connecting Webflow to Xano is quick and seamless.
If you're coming from Webflow and don't have a Xano account follow the instructions labeled: Connect Webflow to a new Xano account.
If you're already using Xano and want to connect Webflow to your account follow the instructions titled: Connect Webflow to an existing Xano account.
Connect Webflow to a New Xano Account On the Webflow Connect page (xano.com/connect/webflow) select Connect to Webflow to get started.
Select Connect to Webflow to get started.
From there, you will be taken to Webflow, enter your Webflow credentials to log into your Webflow account.
Log into your Webflow account.
Next, select which Webflow workspaces and sites you want to connect to Xano.
Choose which Webflow workspaces and sites you want to connect to Xano.
Then, sign up for Xano by entering the required information.
Sign up for Xano.
Enable Webflow for Your Xano Workspace Once you've created an account, open your Xano workspace and navigate to the Connect page.
From there, find the Webflow connection and select Enable to enable Webflow for your Xano workspace.
Enable Webflow from the Connect page of your Xano workspace.
Webflow is now enabled.
Connect Webflow to an Existing Xano Account Navigate to the Account page and select Connect with Webflow.
Next, a Webflow-hosted sign-in page will pop up.
Enter your Webflow credentials to continue.
Log in to your Webflow account.
Select the Webflow workspaces and sites that you want to connect with Xano.
Choose which Webflow workspaces and sites you want to connect to Xano.
After selecting Authorize Application, your account page will show you are connected to Webflow.
The Xano account is connected to Webflow.
Finally, follow the Enable Webflow for your Xano Workspace steps above to connect Webflow to your Xano workspace.
You must enable the Webflow connection to each workspace you want to connect to Webflow.
Using Webflow in Xano Once you've enabled Webflow to your Xano workspace, your workspace will automatically populate with Webflow environment variables so you can seamlessly interact with Webflow in the Function Stack.
Webflow Environment Variables These variables are pulled from your Webflow account once you enable the connection to your Xano workspace -- they cannot be edited or viewed in Xano.
Webflow Environment Variables populated.
Webflow in the Function Stack With Webflow enabled in your Xano workspace, it can be accessed directly in the Function Stack to call Webflow's API.
Webflow is available in the function stack.
A Webflow-specific API request enables you to easily call Webflow's API.
The Webflow API Request.
Once added to the Function Stack, the Webflow API Request will look similar to an External API Request function, but without the Headers section.
This is because Xano will automatically define the appropriate headers including your Webflow API key.
The Webflow API Request in the function stack.
To call a Webflow API, navigate to their API reference (https://developers.webflow.com/) and find the API request that you'd like to perform.
Each API request may have different requirements and parameters.
Xano will handle the API key piece automatically.
Be sure to follow Webflow's API Reference carefully to make successful calls.
In this example, /sites API endpoint will be used to demonstrate how to call Webflow (https://developers.webflow.com/#list-sites).
This API will list the Webflow sites associated with your account.
Webflow API Reference will provide a curl command example, copy this, go back to Xano and open IMPORT CURL in the Webflow API Request function, then paste the curl command.
Once again, please be sure to pay attention to any parameters like unique IDs that are required to make the call. | https://docs.xano.com/fundamentals/connect-to-a-front-end/webflow |
02e74f10e032-1 | The curl command can be found in Webflow's API Reference.
Paste the curl command in Xano and select import.
Once you select import, Xano will create the API call for you.
Notice the path is different than a normal External API Request.
Since Xano knows you are calling Webflow it does not need the full HTTPS address, but rather just the URL path.
If we were calling this in the External API Request function, the entire path would section would need to say: https://api.webflow.com/sites.
The API call for /sites.
When the function is executed, a successful response listing all of our Webflow sites is returned.
The response from the /sites API call.
Fundamentals - Previous Connecting to a Front-End Next - 🗄️ The Database Database Basics Last modified 6mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/fundamentals/connect-to-a-front-end/webflow |
33e75ff09dd6-0 | What is a Database?
Link to YouTube Video: https://www.youtube.com/watch?v=bMmJ0EocmV0 Xano hosts your data on a PostgreSQL database which is the most powerful open source database in the world. It provides the flexibility of a relational database along with the Big data needs of a NoSQL solution. Basic Database concepts to understand Database Basics video course Database tables and setup - Tables are the Entities that make up your application Table view - A spreadsheet-like editor for the content in your Database Field types - The different "types" of content that you can store Database relationships - How to connect data together. Video Course Setting up the Database for your App
Link to YouTube Video: https://www.youtube.com/watch?v=LZZYYYe5U9I Part 1: Database Basics (SQL vs. NoSQL)
Link to YouTube Video: https://www.youtube.com/watch?v=ur7zzyHAMY8 Part 2: Querying Data + Xano Basic Database Setup
Link to YouTube Video: https://www.youtube.com/watch?v=U8LyNwfexno Part 3: Relationships, Addons and Joins Previous Webflow Next Database Tables Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/database |
6ea9ab1baa0e-0 | How Database Tables are setup Xano's Database Table view gives you a high-level overview of the individual tables (or entities) and their associated schema. Database schema shown underneath each table is a blueprint of the database table which specifies what fields are present and their associated types. For example, the user table pictured above has an id column represented by an integer and a name column which is represented by text. Viewing Database Table Relationships Database Tables almost always have some sort of relationship to one another. Clicking on the "Show Table Relationships" checkbox will show how each table is related to one another. You can see the fields that map the Database tables together Adding a new Database Table Thinking through the Database Tables for your App
Link to YouTube Video: https://www.youtube.com/watch?v=LZZYYYe5U9I 🗄️ The Database - Previous Database Basics Next Table View Last modified 11mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/database/how-to-add-a-database-table |
34173cb38f07-0 | The Single Database Table view acts very much like a spreadsheet. you can view, add, edit and delete Database records in a database table. Clear All Records, Optionally Reset Primary ID You can clear all the records in your database table by opening the menu icon in the top right corner and selecting Clear All Records. If you wish to reset your primary ID back to 1, then select the box next to reset primary ID back to 1. **Clear all records is permanent! It is not recommended that you do this unless you are absolutely sure you are okay with losing this data.** Deleting a table You can easily delete a table by clicking the three dots in the top right of the Table view and selecting "Delete" Previous Database Tables Next Adding Database Content Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/database/table-view |
c16a5320fa47-0 | Xano makes adding content to the database very simple with the friendly spreadsheet interface.
1. To get started click on "+ New". 2. You'll notice the different characteristics of the different Field Types.
Some special cases include:
A date picker for the timestamp.
A checkbox for a boolean.
There are other special cases for Storage and Geography values. 3. Let's continue populating the first record. 4. The "Tags" column is special, it is an object with an array of content. Let's click into the cell. 5. Click on add to it and we can create the structure of the object. This is the same workflow as adding database columns. For this example, we can add a name(text) and a rank(integer). 6. So now our first record looks like this: 7. Adding more records is just as easy as adding the first one. Previous Table View Next Database controls Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/database/how-to-add-database-content |
6364d3f0f495-0 | The Database table page contains multiple controls to make it easy for you to create, edit, and view your tables. Let's go over these controls. Search
Perform a simple text search across all your records Sort
Sort your records by multiple columns and asc/desc orders Hide Fields
Clicking on this shows a list of the different columns of the Database table. There is a toggle on the right that can be used to hide columns from the view. Show JSON
This is the way your Database table is represented in JSON. Indexes
Indexing is a way of sorting a number of records on multiple fields. You can read more about Indexes here. API Endpoints
This is the list of API Endpoints that are associated with this Database table. 5. More Actions(ellipsis icon):
This is a drop-down with one action(for now).
Keyboard Shortcuts: This is a list of the current keyboard shortcuts that are used to manipulate the Database table spreadsheet. There are additional controls under the More Actions(ellipsis icon) in the upper right. Settings:
In the Table Settings, you can edit the Title, the description, and the Authentication of the table. You can also delete the table.
Title: name of the table.
Description: internal description about the table.
Authentication: disabled(default) or enabled.
If this is enabled then any time the table is accessed, users can be authenticated by using information stored in that database.
Trash icon: delete the table. Previous Adding Database Content Next Best Practices Last modified 9mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/database/the-different-components-of-the-database-table-page |
182be0c5cdcd-0 | Some tips to help you think through designing your database architecture Designing a database to conform to every best practice the first try is not a simple task, so we hope these items will provide some clarity on the best practices to follow when thinking about the architecture of your Xano database. Use a consistent naming convention for tables and database fields This will help you quickly locate data you are searching for in the database view, as well as when constructing database actions in the Xano function stack. Use data types appropriately and define constraints For example, if you are storing a user's email in your database, you can use the email field type which comes predefined with constraints so that the data matches the defined data type. You also have the ability to apply your own filters to each database field, which will let you enforce certain constraints at the table level. Don't repeat yourself Using features like relational data will ensure that you are able to populate and query your database in the most efficient manner possible. Index columns that are frequently used in custom queries on larger tables Indexes should be used on larger tables (>10,000 records) to ensure your database queries are as performant as possible. Indexing is an advanced topic, and should be approached with care. See our indexing documentation here for more information. Implement proper security measures to protect sensitive data In Xano, this means using features like the API Access on your database fields to ensure full control over what can be accessed and returned by your APIs. Data security is further handled at an API level. See this video for the various methods on how to secure your Xano API endpoints. Back up the database as needed Xano does maintain a 3 day rolling backup of your entire instance for any paid plans. If you need a whole-instance backup restored, please reach out to support and we can accommodate this for you. You also have the option to export a table via CSV through the function stack. Monitor and optimize database performance Xano provides a usage graph to monitor your database compute usage. See this section of our documentation for more details, as well as steps to take if you are seeing high database compute usage. Keep the database design simple and avoid unnecessary complexity. Designing a database is usually something that can require multiple attempts before getting it exactly right, but following the points listed on this page will put you on the right path to avoiding making major architecture changes later in the development cycle. Previous Database controls Next - 🗄️ The Database Field Types Last modified 1mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/database/best-practices |
e369853df766-0 | Xano supports a number of different field types to be used in the building of your database.
While Xano's table editor might appear like a standard spreadsheet, it can store rich content in each cell.
For example, a table can contain records (rows) with attachments, files, checkboxes, location data, links to records in other tables, and much more.
The data type is for the Database to understand what type of data is expected inside of each column, and it's always a way to ensure data is stored in a consistent and known format.
Below are all of the supported Field Types in Xano: Text
variable-length character string.
Typically used for things like titles, names, descriptions and urls
Integer:
A number without decimals.
Used to store whole numbers like age or a credit card number Object: An object is a collection of properties or key values.
Here's a great example of what an object is.
If the object was a car, it's properties might be brand, weight, color, make, year Table Reference: this is what is used to define Table relationships.
It's an integer that references another table using the id .
Used to tell Xano when one piece of content is related to another.
Enum: A list of possible values.
This is typically used when you're doing a list like roles (basic, admin, super admin).
Timestamp: A timestamp is stored as a Unix timestamp in milliseconds.
Anytime you store a date or time, you would use this field type.
Date: Store dates with an easy calendar interface.
Boolean: logical Boolean
When you want to store a true/false checkbox Decimal: You can store a decimal value with 31072 digits before the decimal point to 16383 digits after the decimal point.
Good for when you want to display fractional values Email: Storing an email address
email address format: [email protected].
Password: this is a special case where the data entered into this field is automatically encrypted using salt encryption.
You can also configure how passwords are stored.
Use to store passwords or anything sensitive Image Metadata: this allows you to upload any image files.
For example: .jpg.
Video Metadata: this allows you to upload any video files.
For example: .mp4.
Attachment Metadata: this allows you to upload any files with the exception of .exe.
JSON: Consists of 6 data types.
First four data types (string, number, boolean and null) can be referred as simple data types.
Other two data types (object and array) can be referred as complex data types.
Here's a great article if you want to learn more.
Typically used when you are storing temporary data.
a good example is user-generated data such as filling out a form or data logging.
Storage: Upload a file to Xano.
Timestamp: this is the number of milliseconds that have elapsed since the Unix epoch.
Learn more about Date & Time in Xano Xano supports array (list) structures for each of field types available in the database.
FAQ: When should I put things in an object or list vs a separate table There is no hard and fast rule on this, but we like to say if you anticipate your object list growing over 100, it's probably time to start thinking about separating it into a new table.
You can still keep everything in an object, but it becomes a little unwieldy to manage especially because when you update objects, you're updating the whole thing (so potentially 100+ records) and if you make a mistake on how you update the data on the front-end, it could lead to some trouble.
API Access on field types This feature allows you to further enforce restrictions when it comes to how your Database Fields are displayed using the API.
For example, you might want to change the API access level of any fields containing particularly sensitive information, such as passwords. | https://docs.xano.com/database/field-types |
e369853df766-1 | Public - This field is accessible to be used in any API.
Private - When you create a CRUD API endpoint that references this table, This field will be hidden from the Input section of the NO CODE API builder.
Internal - When you create a CRUD API endpoint that references this table, This field will be hidden from the Input section of the NO CODE API builder AND from the response of any Database Function that accesses it.
Geography Point (geo_point): a special type that represents a point on the map using latitude and longitude.
Point Collection (geo_multipoint): a special type that represents a collection of points on one map using latitude and longitude.
Path (geo_linestring): a collection of points that represent a line on a map using the latitude and longitude of each point.
Path Collection (geo_multilinestring): a collection of lines on one map.
Polygon (geo_polygon): a collection of lines that form a multi-sided shape on a map.
Polygon Collection (geo_multipolygon): a collection of polygons on one map.
Previous Best Practices Next Geography Last modified 3mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/field-types |
1c383cd30b7c-0 | Geography Data Types are special cases in the Database which allow you to store geographical data based on the different characteristics. When you are adding content to one of these columns a different interface will show up. There will be a map that you can manipulate to find exactly what you need and make the shapes that are useful to your app.
An example of this can be a polygon around a certain area that acts like an invisible fence that your users can trigger when they enter it with your app. Features of the map:
1. Search Box: you search for any address in this input field.
2. Clear: this clears all items that were created on the map.
3. Add: this creates a new item on the map, depending on the selected type you can have only 1 item or multiple items.
4. Save: this saves the added item(s).
5. + (zoom in): this gives a more magnified view of the map for more specific locations.
6. - (zoom out): this gives a bigger picture view of the map to draw broader items. Point: Point of Lat/Long coordinates.
This allows you to put a single point on the map. This point is then converted into the relative Latitude and Longitude coordinates. You can click on the point and drag it to where you want it to go. JSON Data Format: "point": { "type": "point", "data": { "lng": a, "lat": b } } Point Collection: Collection of points. JSON Data Format: "point_collection": { "type": "points", "data": [ { "lng": a, "lat": b }, { "lng": c, "lat": d }, { "lng": e, "lat": f } ] } Path: Path of Lat/Long coordinates.
This creates a line using two connected points. By clicking on the line, you can drag it to where you want it. By clicking the ends of the line you can increase or decrease the distance between the two points. JSON Data Format: "path": { "type": "path", "data": [ { "lng": a, "lat": b }, { "lng": c, "lat": d } ] } Path Collection: Collection of paths. JSON Data Format: "path_collection": { "type": "paths", "data": [ [ { "lng": a, "lat": b }, { "lng": c, "lat": d }, { "lng": e, "lat": f } ], [ { "lng": g, "lat": h }, { "lng": i, "lat": j } ] ] } Polygon: Polygon of Lat/Long coordinates. JSON Data Format: "polygon": { "type": "poly", "data": [ { "lng": a, "lat": b }, { "lng": c, "lat": d }, { "lng": e, "lat": f }, { "lng": g, "lat": h }, { "lng": i, "lat": j } ] } Polygon Collection: Collection of polygons. JSON Data Format: "polygon_collection": { "type": "polys", "data": [ [ { "lng": a, "lat": b }, { "lng": c, "lat": d }, { "lng": e, "lat": f }, { "lng": g, "lat": h }, { "lng": i, "lat": j } ], [ { "lng": k, "lat": l }, { "lng": m, "lat": n }, { "lng": o, "lat": p }, { "lng": q, "lat": r }, { "lng": s, "lat": t } ] ] } 🗄️ The Database - Previous Field Types Next Storage Last modified 1mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/field-types/special-datatypes-geography |
19ca14e7ea63-0 | Storage Data Types allow for the storage of various BLOBs (Binary Large OBjects). This allows the upload of images, videos, and attachments of different file types. How does Xano store files? Xano does not store the actual files in the Database for performance reasons. Instead, Xano stores a reference to the file for quick retrieval. Uploading Images How to use the uploader in the database spreadsheet to add content: After clicking into the cell, the ability to upload will appear. 2. After uploading an image, a thumbnail will appear. 3. You can click on the image to see a full-screen magnified view, where you can download the image. 4. To delete the image: click on the cell and press the delete key. Re-sizing images Xano has an engine that can dynamically re-size images in real-time so you don't have to store multiple sizes. Bulk Upload There is a special function that appears in the column dropdown called Bulk Upload, you can use this function to add images to multiple records at once. This will create additional records for each of the additional images. Storage Metadata When retrieving the storage Data Types from the Database there is different metadata for each type. This is the information that is returned from the API response. Image Metadata: JSON Data Format: "image": { "path": "/blob/d2cuLg.cCY6PPQHMOg/puppies.jpg", "name": "puppies.jpg", "type": "image", "size": 1914937, "mime": "image/jpeg", "meta": { "width": 5184, "height": 3888 } } Video Metadata: JSON Data Format: "video": { "path": "/blob/eWcuLg.jvyBBXQhAcs/Sample Video.mp4", "name": "Sample Video.mp4", "type": "video", "size": 13268927, "mime": "video/mp4", "meta": { "audio": { "freq": 48000, "codec": "aac (LC) (mp4a / 0x6134706D)", "bitrate": 137000 }, "video": { "dar": false, "fps": 25, "par": false, "res": "1280x720", "codec": "h264 (High) (avc1 / 0x31637661)", "bitrate": 1563000, "profile": "yuv420p(tv", "postWidth": 1280, "postHeight": 720 }, "duration": 62.29 } } Attachment Metadata: JSON Data Format: "file": { "path": "/blob/elEuLg.THaCaO6QKR8/dummy.pdf", "name": "dummy.pdf", "type": "pdf", "size": 13264, "mime": "application/pdf", "meta": { "pages": [ { "res": "595x842" } ] } } Previous Geography Next Password Configuration Last modified 11mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/field-types/special-datatypes-storage |
a5bfc9e07964-0 | Passwords requirements are fully customizable with a few handy filters. The Password data type is configurable so that you can specify the desired password requirements for your application. The default settings in Xano requires a minimum of 8 characters, 1 alphabetical character, and 1 numeric character. You can either start with a new field:
When creating a password field, click on CONFIGURE INPUT to add different filters/requirements. Click configure input if you are creating a brand new password field. Or edit an existing one:
Click on an existing password field and select the settings, from there, you can change the default settings or add additional filters. If a password field already exists, then click on the field then click on settings to change the default settings or add additional filters. There are a number of different filters to choose from, so that you can be as exact as needed. min: Enforces a minimum length for the entry length. max: Enforces a maximum length for the entry length. minAlpha: Enforces a minimum number of alpha characters. minLowerAlpha: Enforces a minimum number of lowercase alpha characters. minUpperAlpha: Enforces a minimum number of uppercase alpha characters. minDigit: Enforces a minimum number of numeric characters. minSymbol: Enforces a minimum number of punctuation characters. Previous Storage Next - 🗄️ The Database Database Relationships Last modified 2yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/field-types/password-configuration |
a5771bce93e2-0 | Xano makes it easy to visualize and select relationships of your database tables.
Basic Relationships
Link to YouTube Video: https://www.youtube.com/watch?v=pT_879zMDpk&t=307s In Xano, a relationship between database tables is created using the Field type Table reference Relationship data display
A table reference is typically just an integer referencing the unique ID number from the table of the referenced record.
However, oftentimes it's helpful to visualize what the reference represents beyond just the ID.
With Xano, you can see the fields of your referenced record that are important to your use case.
In this example, we are viewing the deals table.
Each deal has a relationship to a merchant record, as signified by the merchant_id field.
Each field is displaying data from the merchant table including the name, description, and id of each merchant record.
Visualize and Auto-complete Database Relationships
Link to YouTube Video: https://www.youtube.com/watch?v=5dVa902Lou4 Auto-complete relationships
When entering a reference record, Xano presents you with a drop-down menu.
The menu provides you with the recently added records from the table you are referencing.
Additionally, there is a search bar where you can search for the id number or any of the displayed field values.
You can quickly navigate using the keyboard arrows and enter key.
In this example, the current value is Firestone BBQ #1.
There is an auto-generated list of the most recently added records from the merchant table.
Additionally, we can search for any of the displayed fields and the record id #.
Choosing which data to display
By default, Xano will automatically display the first text field and the id field of the referenced table record.
However, you can easily customize which data you'd like to be displayed in your table reference.
In the parent table (or the table being referenced), click the menu icon in the top right (three dots), then select Auto-Complete.
In this example, the parent table or table being referenced would be the merchant table.
In this example, select Auto-Complete in the merchant table to customize which data is to be displayed in other tables referencing the merchant table.
After selecting Auto-Complete, the settings will open up.
Click customize in order to customize the display of the referenced data.
Once the Auto-Complete settings open, click Customize to customize the layout of the display.
You can add multiple columns, reorder the columns displayed, and remove columns from the display.
In this example, the displayed columns are name, description, and id - in that order.
Many-to-Many relationships
Link to YouTube Video: https://www.youtube.com/watch?v=3T8DQ6aAQBw&t=428s There are a few ways to handle Many-to-Many Database relationships within Xano.
▶️ This is also covered in Part 2 of our Database series An example of a many-to many relationship is one between students and classes.
A student can register for many classes, and a class can include many students.
The traditional SQL to set this up has been to use a JOIN or pivot table which you can absolutely still do in Xano: However, Xano allows you to do it another way
Xano uses PostgreSQL, which is essentially a hybrid SQL/NoSQL database.
You can simply create a list (array) of classes in the student table that allows you to not only achieve the same thing but have data locality (being able to see everything in one place).
Here's a demonstration of how you would add a class list directly inside the student table: Add a field from the student table Select a table reference Select class (or the item that will have the many relationship) Select the column header for class_id and select Change Type from the drop-down menu.
Change 'Structure' from Single to List.
Double-click into the field to be able to add to the list of classes. | https://docs.xano.com/database/database-relationships |
a5771bce93e2-1 | See how the enrollments are displayed directly on the student FAQ: When should I put things in an object or list vs a separate table There is no hard and fast rule on this, but we like to say if you anticipate your object list growing over 100, it's probably time to start thinking about separating it into a new table.
You can still keep everything in an object, but it becomes a little unwieldy to manage especially because when you update objects, you're updating the whole thing (so potentially 100+ records) and if you make a mistake on how you update the data on the front-end, it could lead to some trouble.
Previous Password Configuration Next - 🗄️ The Database Data Sources Last modified 4mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/database-relationships |
d67d8ab4f4c1-0 | Data sources refer to the different types of data environments available throughout a Xano workspace. For example, the Scale plan supports two environments for data sources: live (production) and test. Your live data source is the data that is live for your application. Test data source allows you to create test data with the same schema set up so that you can run tests without affecting your users' data. Plans with data source environments: Scale and Enterprise The Scale plan supports two data source environments: live and test. Enterprise supports multiple data source environments. To see more about each plan please visit pricing. In order to upgrade, navigate to billing within your account. Adding and navigating a new data source environment You can add a new data source from the database section of your workspace. Easily see which data source is currently active. Next to that, select change to add a new data source or to navigate to a different environment. The database shows the active data source. Select change to add a test environment or navigate between existing environments. Once you select '+ Add Test Data Source' you will be taken to the data source manager panel where you can add a new test environment. Important: Editing and Schema of Data Sources It's important to note that a test data source will have exactly the same data schema and structure as your live environment. You cannot change, edit, or delete the schema or database tables in your test data source environment. The test environment allows you to use different data or records so that you can perform tests in your API without affecting your live data. A test data source does not copy your live data. It has only the same schema so that you can add test or dummy data. You are able to delete your test data source to easily start over. However, you cannot delete your live data source or change which data source is live and test. When in a test data source environment, Xano will notify you throughout your workspace with a banner at the top of the page. You can easily switch back to live data at any time by select 'switch back' or 'change' in the database. Xano will notify you throughout your workspace when you have a test data source active. How to use the test Data Source with your API requests Set Header Method By default all API requests use the live data source, however, you can change that with the following HTTP header below. Use this header in your API requests to define the data source: X-Data-Source: test For Enterprise users that have multiple data sources available, you would change the word test with the correct name for your data source you want to use with your API request. URL Argument Method The other method to make API requests use the test data source is through a URL argument. You can append the argument to your API endpoint URL. ?x-data-source=test https://x1xx-abcd-efgh.a1.xano.io/api:x123abc/user?x-data-source=test This method is especially helpful for sending webhooks to your test data source when the webhook doesn't support additional headers. 🗄️ The Database - Previous Database Relationships Next - 🗄️ The Database Database Performance Last modified 9d ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/data-sources |
d645920e395f-0 | There are several best practices when it comes to optimizing your Database's speed and performance. This is an iterative process but will become important especially as you start to work with larger data sets of over 10,000 records. There are three variables when it comes to database performance: Database Model Design Querying Data Efficiently Setting up Indexes 1. Database Model Design A database model is the logical structure of a database, including its relationships and any constraints that determine how data can be stored and accessed. Designing your Database Model in the "right" way for your specific application will make a big difference in how performant your app will be. This is really hard to get right the first time and usually takes a few iterations, but some best practices might help you get off to the right start. 2. Querying Data Efficiently This usually goes hand in hand with efficient Database design, but if you've modeled your Database in the most performant way possible, the next thing to do is look at the way you query data. This usually involves using Addons where possible to enrich your API response with related data rather than trying to get it recursively or with joins. 3. Setting up Indexes Indexes are a powerful tool used to speed up querying data. You can think of an index similar to a table of contents "index" in the back of a book. When you want to quickly look up something, you refer to the index and jump to the page. Xano automatically indexes your data in the most performant way it knows how, but if you want to provide a specific pointer to data that's important to you in the table, you would define a new Index. 🗄️ The Database - Previous Data Sources Next Indexes Last modified 2d ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/database-performance |
3416a75f4cea-0 | Indexing is a way of increasing performance of queries on large tables.
Link to YouTube Video: https://www.youtube.com/watch?v=hpb5PuFdki4 What is an Index?
An index is a database feature that helps improve the speed and efficiency of queries made against a database table.
They help when searching through large, unordered data sets and give the database search engine a quick way to sort and find specific data.
Indexes can be created using one or more columns of a database table, providing the basis for both rapid random lookups and efficient access to ordered records.
How do they work?
A table index is very similar in practice to the index of a textbook.
When there is a specific piece of information that you want to find, reading every page of that book to find what you are looking for can be very slow and inefficient.
So, you would use the index at the back of the book to find exactly which page contains the information you need.
This is the same concept for a database table index.
They create a special type of lookup table in the background that the database engine can use to retrieve the data faster than looking through each individual row for every search.
When to use an Index?
Indexes are the most beneficial in the following scenario(s): You have a specific query that you want to ensure is as performant as possible The query uses simple operators in one or more conditions Yes: Where user region = Canada No: Where user ID is even, or user region is empty The table has 10,000 records or more The data you are looking for lives in a field with a large number of unique values The table is not frequently written to or updated This is because when a table is indexed and frequently written to, the performance of inserting new data can suffer because the index has to be updated at the same time.
You can index a table that has frequent writes, but use caution.
How do I apply an index properly?
It’s important to construct your index based on the query being performed that you are trying to address.
We will use the an example scenario to explain an approach to indexing.
All scenarios were built and performed on a Launch plan instance with no additional load or processing.
Your results may vary based on other factors related to your specific instance or the plan you are on.
Example Table: 515,195 records id name region country profession firstname lastname email birthday Example Query: Find all users in a specific country, with a specific profession Example query with no indexing With no indexing applied, this query takes 0.62 seconds to complete.
Because these two pieces of data can exist independently of each other -- meaning we don't need to know a country to determine a profession, and vice versa, we will apply two separate indexes to our table, one for each field.
Indexes applied based on the sample query With these indexes applied, the example query now executes in 0.05 seconds, a 95% increase in query speed.
Example query with indexing applied When should I index a single field by itself vs multiple fields in the same index?
This is based on the hierarchy of the query being performed, and what makes the most sense in terms of your data set.
It’s important to think about what fields relate to each other; what fields in your query require the data from others to make sense in context?
It is also important to note that if you have multiple fields defined in a single index, but are not using both of those fields in your query, the index will not provide any benefit to the performance of that query.
Indexes are only useful if you are indexing based on the queries you are making, and the hierarchy of your query makes sense.
You can use a field in a double field index as well as a single field index, but it is important to consider the storage requirement for each index you create. | https://docs.xano.com/database/database-performance/indexes |
3416a75f4cea-1 | In addition, it is possible to ‘trap’ yourself into a situation where you have too many indexes and it becomes more difficult to determine what is helping and what is not.
Example Query: Find all users who are part of a specific subset of artists Example query with no indexing Executing the example query, with no indexing applied, takes 1.44s.
Because we know that the artist_service field requires the profession field to make sense in the context of our query, we will place both of those fields, in order, in the same index.
Applying the index for the example query Example query results with indexing applied After applying the index shown, this query completes in 0.02 seconds, 98% faster.
Using the GIN Index to search complex data types The GIN index is used specifically when searching through more complex data types, such as objects and arrays, as these fields can not be indexed using the methods described previously.
This index is automatically applied to all of your database tables; you do not need to add or maintain this.
Let's say, as an example, we have a list field called my_list, and we want to find all records that contain a value of special inside of my_list.
To use the GIN index in this query, we first need to create a variable with the following structure: {"my_list":[ "special" ] } The structure starts with an object containing the name of the field, with the value being an empty array.
We then use the push filter to add the value we are searching for inside of that list.
You can use multiple push filters to search for multiple values.
Constructing the variable to be used in our query Once we have our object constructed, we will set up our custom query by selecting the table on the left side, which leaves us with the 'contains' operator, and our constructed object on the right.
An example of a GIN index query In this example, a query without indexing takes 0.23 seconds.
In this example, utilizing the GIN index, the query takes 0.02 seconds.
How to Apply an Index in the Database View In the database view, click on the table that you want to index.
Choose "Indexes" from the top bar.
Click "Create Index" to add a new index, or click on an existing index to manage it.
Choose the fields, sort, and index type.
When done, click 'Save'.
Note: Creating or updating an index can take several minutes depending on the complexity and the size of the database table.
Note: Indexes will significantly increase the storage your databse table requires.
Please ensure you have enough free space (we recommend trying to stay around ~50% free space) before indexing your tables.
Types of Indexes Primary Automatically applied and maintained Indexes the primary key (ID) of each record and enforces uniqueness GIN Automatically applied and maintained Most suitable for complex data types (JSON, lists, objects) and full-text search Index The most common index type Used when indexing for standard queries Unique A special type of index to enforce unique values in a column’ Spatial A special type of index designed to optimize queries involving spatial data, such as geography fields.
Search A special type of index to be used in conjunction with Xano fuzzy search When should you not use an index?
Do not use an index on a table containing only a few records.
They are most valuable when your record count approaches >5,000 records.
Indexes should not be used on fields that have or will have a high number of null values, because that essentially means there is nothing to index on.
You can not apply a normal index to an array or object field, so keep that in mind when designing your database structure.
You can use the automatically maintained GIN index, detailed later on this page.
If your field / column names are frequently changing, you should not index that field. | https://docs.xano.com/database/database-performance/indexes |
3416a75f4cea-2 | If a table is frequently used to add / edit data, it may be best practice to not index this table.
While your query speeds can still benefit, they can also slow the performance of adding to or editing data on this table given the nature of creating an index behind the scenes.
🗄️ The Database - Previous Database Performance Next Maintenance Last modified 27d ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/database-performance/indexes |
a1d0c6e83f02-0 | Database maintenance is automatically done daily but Xano does offer ways to manually run PostgreSQL analyze and vacuum commands through the Instance Maintenance panel.
PostgreSQL's VACUUM and ANALYZE functions are essential maintenance tasks for optimizing database performance.
Together, VACUUM and ANALYZE help keep the database running smoothly by managing storage and providing accurate statistics for optimal query planning and execution. Analyze ANALYZE gathers statistics about the data distribution in tables, enabling the query optimizer to generate efficient execution plans. It updates the query planner's knowledge of the data, improving query performance by enabling better index selection and join strategies. Vacuum VACUUM reclaims storage space by removing obsolete or dead data that remains after updates or deletions. It helps prevent performance degradation caused by fragmentation and frees up disk space. Partial VACUUM This command analyzes and cleans up the database, but it does not necessarily reclaim all available disk space. It marks the space previously occupied by deleted rows as reusable for future inserts and updates. VACUUM also updates statistics used by the query planner to improve query performance. Full VACUUM This command performs a more thorough cleanup compared to partial. It reclaims all available disk space by rewriting the entire table and indexes from scratch. This process can be more resource-intensive and time-consuming, as it involves copying the data to a new file and rebuilding the indexes. Full VACUUM can significantly improve disk space utilization but may cause downtime for larger tables. Previous Indexes Next - 🗄️ The Database Database Storage Last modified 2d ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/database-performance/maintenance |
17e62166fc85-0 | Database storage uses high-performance solid-state drives (SSD). This storage is used only for the database schema, the metadata of each database record, and the indexes on the metadata. Any media references in the database records would be metadata only as the actual binary of this media is stored in separate media storage. Explaining Database Usage In Xano, your data is stored in a PostgreSQL database, which allows for incredibly powerful structure, scalability, and speed. In your dashboard, you have the ability to see exactly how much of your database storage is occupied, to help guide you in making decisions about what data to keep, or if it’s time to upgrade your instance with more storage to suit your needs. Database storage is different from file storage. Think of a folder on your computer that you delete a file inside of. When you do this, your computer doesn’t immediately destroy the data – that file is hidden from you, marked as inaccessible, and the storage that file occupies is now marked as available. Your computer then calculates the available storage, taking this newly available space into account. This all happens in real time. Now, in terms of a database, where your Xano data is stored, deleting a row does not immediately remove this row from your storage. This approach is required to ensure that things like versioning and backups can still continue to function, and to account for anything else that may still be accessing that data. Eventually, that data will not be relevant to any operation, and the space it occupies must then be reclaimed for reuse by new rows. This is something that occurs on your workspace at regular intervals with scheduled maintenance. I deleted some records, but my storage is still the same. What’s going on? As stated above, when records are removed, to support certain Xano features, as well as by design on the PostgreSQL database, that space is not immediately going to be marked as available and computed in your storage statistics – however, eventually the space those records were occupying will be reused when adding new records. In addition, it’s important to remember when considering this that a database table with 1000 records, that has had 999 of them deleted, is not the same in terms of structure or storage requirements as a brand new table with only one record. My storage usage doesn’t seem to be updating. Your storage statistics are updated at regular intervals throughout the day, and are not real-time. We’d love to be able to offer more control over data architecture and maintenance in the future, and if that’s something you are looking for, make sure to let us know on our feature request board. What is actually taking up database storage? There are several different components that make up your Xano database, and they can all contribute to database storage. This includes: Database table schema
What fields you've set and the settings that accompany them Records
This is your actual data that you are storing in your database. Indexes
Some indexes are auto-generated and required to maintain your table. Others are manually added by you, and can take up a varying amount of space. Task and Request History
When you make requests to your Xano APIs or run background tasks, this history is logged on a 24-hour rolling cycle. Sometimes, if you have an exceptional amount of history, this will be reflected as used database storage, as it is stored in a similar fashion to your database records behind the scenes. Previous Maintenance Next - 🗄️ The Database Database Views Last modified 2mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/database-storage |
f7177163c833-0 | Build and save separate database views for easier navigation When using the filter and sort options in the database, you can save these settings as views to quickly access them again later. You can combine both filters and sorting to create your desired database view. Saving a Database View Once you have constructed your desired database view, click the Save View button that appears in the top menu. Give your view a name, and click Save. Switching and Deleting Views To switch between views, click the Views option in the top menu and select your desired view, or switch back to the default view. To delete a view, click the delete button in the lower-left corner of the panel, and select the view you'd like to delete. 🗄️ The Database - Previous Database Storage Next - 🗄️ The Database Importing data Last modified 2mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/database-views |
6c8349cc7260-0 | Import data into your Xano Workspace How Can I import Data into Xano? We are working on a number of different wants to easily bring data into Xano. Below are methods we currently support: Airtable Import
Sync your bases, relationships, and content. CSV Import
Xano's CSV import is ultra-robust and can handle your largest CSV files. SQL / PostgreSQL
Migrate your SQL database to Xano by exporting tables to CSV files and using Xano's CSV import. Send a CSV to XANO with Parabola
Link to YouTube Video: https://www.youtube.com/watch?v=m6700GSTMDE JSON Import
Supported using the External API request in the function stack or by creating a variable and using the import JSON feature to add it to your database. If your JSON is a list (array) then you will need to iterate through the list with a loop in order to add records to the database. YAML Imported
Supported using the External API request in the function stack 🗄️ The Database - Previous Database Views Next CSV File Import Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/importing-data |
d9d4f495e875-0 | Xano's CSV file import is ultra-robust.
Import your file with confidence, even if you have millions of records.
The import process runs on Xano's special import service, which has dedicated resources separate from your instance, so it can handle all of your data no matter how large it is.
The CSV file import allows you to create a brand new table from scratch and will generate the schema automatically.
Additionally, you can edit existing records if the file can be mapped to a primary key or append data to an existing table.
Uploads over 5,000 records will be performed in the background.
You can easily monitor the import's progress in the settings of your workspace and will be notified on Xano and via email when the import is complete.
Add a New Table From the database select Add Table.
When the right panel opens up, select Import and choose the CSV file option.
Next, drag and drop a CSV file onto the uploader or browse the files on your computer for the file you wish to upload.
Once you select a CSV file, the preview of your CSV will open up.
The preview will display the first 100 rows of your file.
You can make any final adjustments here before uploading the file to Xano.
Choose a table name Set a field as the Primary Key Xano will try to automatically detect a primary key field.
Currently, only integers are supported for the primary key field.
The drop-down will show any fields compatible to be a primary key.
If there is no primary key, then Xano will create the primary key automatically.
Make any changes Lastly, you can select a column to change its data type, disable it (if you do not want it included in the upload), or re-order the column's position.
Upload and finish!
Once you are ready select upload!
If you are uploading over 5,000 records then your upload will be performed in the background.
You can monitor the progress of your upload from the settings page of your workspace.
Once your background upload is complete a green banner will appear notifying you to refresh your browser and an email notification will be sent with confirmation of a successful import.
Add to an Existing Table Choose the table you want to add data to via a CSV, select the menu icon in the top-right, and select CSV Import.
Drag and drop a CSV file onto the uploader or choose a file from your computer.
Next, a preview of your CSV will appear.
The first 100 records will be displayed.
Review the mapped columns before selecting upload.
Any column headers in green will show automatically detected mapped fields.
To make a change, select a column and choose a different column to map to.
You can also select create a new column if you need to create new schema for the table.
Hit upload and finish!
Edit Records in an Existing Table To edit an existing record the CSV file must have a primary key.
The primary key will be mapped to the primary key of the existing records to make the updates.
Currently, only integers are supported for the primary key field.
If there is no primary key to map to the existing id field the CSV file will add new records to the table.
Be sure to review the column mappings before uploading.
Xano will search for a column in the file called ID.
However, double check this field.
If your ID field is called something else, click on the column and choose to map the column to the existing ID field.
You can make changes to any of the columns mapping's by clicking on the column header.
Green will show a compatible mapping to a field.
Any red headers indicate an unmapped column.
Finally, you can also select create the column if you need to create a new column on the table.
Valid CSV File Format It's important that you use a valid CSV file format in order to successfully import your data.
If there is an issue with initiating the upload then this could likely be the issue.
What is a valid CSV file format? | https://docs.xano.com/database/importing-data/csv-file-import |
d9d4f495e875-1 | A CSV stands for a comma-separate file, which is a delimited text file that uses a comma to separate values.
The importer does not support other separators, such as semicolons.
Each line of the file is a data record.
Each record consists of one or more fields, separated by commas.
The first row must contain the column names - not the file name or any other data.
The second row begins the values.
They should be in the same order as the columns they belong to.
Each row should have the same amount of values as there are columns.
Enclosure characters are required when working with text strings that contain quotation marks.
This is because if a quotation mark is detected, this is typically something that would mark the beginning or end of a value.
You can use a double quote ("") to dictate if a value should contain this quotation mark somewhere inside the value.
CSV files should be UTF-8 encoded.
If you're having trouble importing your CSV properly in Xano and have determined you are using both the proper separator and enclosure characters, please make sure your file us UTF-8 encoded.
This ensures that there are no special characters that might not be supported in Xano.
UTF-8 Encoding in Notepad (Windows) UTF-8 Encoding in Google Sheets (All platforms) UTF-8 Encoding in Numbers (Mac) Xano-Sample-CSV.csv 160B Text Here is a sample CSV file demonstrating both the proper separator and enclosure characters.
How can I check my CSV file format?
You can review the format of your CSV file format in a number of ways.
Open the file in Text Editor, Visual Studio Code, or another code editor.
You can also do an online search for CSV file format validators and use an online service.
How can I edit my CSV file format?
Tools like Text Editor, Visual Studio Code, and other code editors allow you to make any necessary edits to your file and save the changes.
When opening the file from your computer, right click and choose open with to choose from the different options available on your computer.
🗄️ The Database - Previous Importing data Next Airtable Import Last modified 3mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/importing-data/csv-file-import |
67c6a1e7ce56-0 | Import a sheet from Airtable into the Xano database Xano makes it easy to import your data from Airtable to your Xano database. First, on the Xano database page, click "Add Table" Click "Add Table" Next, go to the "Import" tab and select Airtable. After selecting "Add Table", go to the "Import" tab and select Airtable. Enter in your Airtable API Key. This is found by going to your Account page in Airtable then clicking "Generate API Key." Once generated, copy the key and paste it into Xano. Paste in your Airtable API Key. How to find your Airtable API Key Go to the Account page in Airtable. This is found by clicking on your user icon in the top right corner and clicking on "Account" in the drop down. In Airtable, access your Account page by clicking your user icon in the top right corner, then selecting "Account." Once on your Account page in Airtable, locate the Generate API Key button and click it to generate your API Key. (You may have one generated already, in that case, you may copy the existing one or re-generate a new one if you'd like). On the Account page in Airtable, click Generate API Key. Once you've entered in the Airtable API Key you will be able to connect to your Airtable account. You can choose a Base, table, and view to import from Airtable. Choose a Base to import from Airtable. Choose a table to import from Airtable. Choose a View to import from Airtable. Finally, confirm the import settings and click "Import." Confirm the Import settings and select "Import." Depending on how much data you are importing this may take several seconds. Airtable only allows for 100 records of data per second to be sent through their API, so please keep that in mind. Supported Data Types The following are supported data types that can be imported from Airtable and the data types in Xano which they will be imported as. count -> integer formula -> text autoNumber -> integer duration -> text barcode -> text rating -> integer currency -> decimal percent -> decimal richText -> text singleLineText -> text multilineText -> text phoneNumber -> text url -> text email -> email singleSelect -> enum (text default) multipleSelects -> [] enum (text default) number -> decimal checkbox -> boolean lastModifiedTime -> timestamp date -> timestamp multipleRecordsLinks -> [] integer (table reference) createdBy -> integer (table reference) lastModifiedBy -> integer (table reference) singleCollaborator -> integer (table reference) multipleCollaborators -> [] integer (table reference) multipleAttachments -> [] attachment (text default) Rollup -> text* *Rollup is a formula-based data type unique to Airtable, we are only able to import a text copy of the data. Previous CSV File Import Next SQL / PostgreSQL Last modified 3mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/importing-data/airtable-import |
642e92efb794-0 | Xano is robust enough to handle large amounts of data with the right plan. Often times users may wish to migrate their backends to Xano from another solution. Occasionally, they may already have large quantities of data living in a SQL database. Xano doesn't allow for use of an external database but many are successful migrating their data from a SQL database to Xano's database. The CSV import is limitless and can handle files no matter how large they are. In order to migrate a SQL database to Xano, it is first recommended to export each table into a CSV file. With each table in a CSV file, you can import the data table by table using the CSV file import feature. The CSV file import will perform in the background on dedicated resources, which are separate from your instance's resources. This allows Xano to handle millions upon millions of records. Please allow time for the import process to complete. You can monitor the progress from the settings page of your workspace and will be notified via email once the import process is complete. Previous Airtable Import Next - 🗄️ The Database Exporting Data Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/importing-data/sql-postgresql |
f457c545a9de-0 | Exporting your Xano database tables Export an entire table via the Database View From the Database view, click the three dots in the top-right corner and choose Export CSV. You will be presented with a dialogue to initiate the export. These exports take place in the background and you will receive an email notification once complete. CSV export has support for database views if you want to export specifically filtered or sorted data. Export specific rows to CSV Use the checkboxes on the left-hand side of the table view to select specific rows to export. You can also navigate to different pages of the table to select records on multiple pages. Once you have selected your desired records, click Export. Export a CSV via the Function Stack
Link to YouTube Video: https://www.youtube.com/watch?v=wy2jXKLXEvw Previous SQL / PostgreSQL Next - The API API Basics Last modified 1mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/database/exporting-data |
c0c7c76d30bd-0 | What is an API/API Endpoint? You can think of the API like a messenger that runs back and forth between your database and other services to collect information and eventually pass it to your front-end. Each individual command that the messenger (API) knows is called an API Endpoint.
Link to YouTube Video: https://www.youtube.com/watch?v=knWgT8oI1Qc
Link to YouTube Video: https://www.youtube.com/watch?v=yeG8VRs7wbE What is a REST API? You've probably heard of the term REST API or RESTful API. REST is simply an architectural style that the vast majority of web services use to communicate with one another. It stands for representational state transfer and was created by the computer scientist Roy Fielding. API Basic Concepts API Groups - Folders for your API endpoints with unique documentation and BaseURLs. Creating an API Endpoint - Build API endpoints to perform more unique or complex operations. Naming your API Endpoints - Learn best practices when it comes to naming your API Endpoints. API Status Codes - When you perform an API request to your servers or others, it's important to understand the codes gettings sent back to you. The NO CODE API Builder - Learn the anatomy of an API endpoint and how to build an API. 🗄️ The Database - Previous Exporting Data Next API Groups Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/the-basics |
2838023a778d-0 | Folders for your API endpoints with unique documentation and BaseURLs API Groups allow you to organize your API endpoints into logical "Folders". Each of these API endpoints has its own Documentation and unique BaseURL.
Link to YouTube Video: https://www.youtube.com/watch?v=j81WdVJfX1s Xano Creates your CRUD Operations in an API Group called Default The API Group My First API Group is a group that contains CRUD API Endpoints to modify data in the Database Table My First Database Table. What are API Groups used for Visually separating your API Endpoints Managing access between different types of groups (General vs Admin API Endpoints) Separating out API Endpoints from Marketplace Extensions Managing different versions of an API endpoint Clicking inside an API Group The API - Previous API Basics Next CRUD Operations Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/the-basics/api-groups |
9a1158154dfa-0 | In computer programming, create, read, update, and delete (CRUD) are the four basic functions of persistent storage. CRUD (Create. Read. Update. Delete) API Endpoints Xano can auto-generate basic CRUD API operations for each table you create which makes it easy to retrieve, send and delete data from your database. Of course, you can get as complex as you need to be in Xano but understanding the basics is essential. ▶️ Create (POST) operation ▶️ Read (READ) operation ▶️ Update (POST) operation ▶️ Delete (DEL) operation Here they are in more detail Create: This API creates a new record in the database. Read(single user): This API gets a single record in the database using the defined input, in this example, we can use the primary ID. Read(all users): This API gets all records in the database. Update: This API updates a single record that is found by a certain input. In this example, we can use the primary ID. Delete: This API deletes a record in the database by using a certain input. In this example, we can use the primary ID. Previous API Groups Next Creating an API Endpoint Last modified 4mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/the-basics/crud-operations |
d82c8d1619ad-0 | What is an API Endpoint? If an API is considered the messenger passes data from your backend to your front-end, each individual API endpoint defines the specific command that messenger knows.
Link to YouTube Video: https://www.youtube.com/watch?v=ip8RPYyDlGI API Endpoint verbs API Endpoints have a "method" or HTTP Verb associated them and the most common are POST, GET, PUT, PATCH, and DELETE. These verbs correspond to the CRUD (Create, Read, Update, Delete) operations, respectively. When you create an API endpoint, you must first define what type of verb it is. The API Endpoint verb doesn't necessarily dictate exactly what can/can't happen in the Function Stack of the API. This means just because you're creating an API endpoint with the verb DELETE, doesn't mean you can't add records to a database when it gets called. When to create an API Endpoint Most applications need something beyond basic CRUD operations and require you to create custom business logic in an API endpoint. Xano makes this easy. How to create an API endpoint API Endpoint Options CRUD Database Operation - Adds an API endpoint using a CRUD Operation to a database table. Authentication - Creates an API endpoint with authentication logic
auth/login Allows a user to login and generates a JWE token that lets them login.
auth/signup Allows a user to sign up to your app and generates a token for them to login.auth/me returns the authenticated user Upload Content - Creates an API endpoint that allows you to upload Images, videos or attachments. Import Query - You import any API endpoint you've exported using the three-dot menu Start from scratch - Define the API name, Verb, and description from scratch NOTE: Any of these API endpoints can be manipulated and changed to anything you want. These options just make it easy for you to generate useful API Endpoints quickly. Naming your API Endpoints Previous CRUD Operations Next Authenticated API Requests Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/the-basics/custom |
a684eceee76f-0 | How to perform an authenticated request You can set up your API Endpoints to require user authentication in order to access them:
Link to YouTube Video: https://www.youtube.com/watch?v=TiUl1Z8WDXo Related How to Set up User Sign up and Log in using your API How an Authenticated request works An Authenticated API request requires an access token to grant access in order to perform the API request.
First, a token must be retrieved and then passed into the header of the API endpoint requiring authentication.
Xano uses JWE authentication tokens, which is a standard.
You can read more on the Authentication page.
Xano creates three Authentication endpoints out-of-the-box.
Two of them retrieve an authentication token: signup and login.
And one requires an authentication token: GET the user record belonging to me.
(Note: you can learn more about how to change, enable, and disable authentication settings here).
Authentication Header Per standard, JWE tokens are passed in the header of an API call using this format: Authorization: Bearer xxx.yyy.zzz Where xxx.yyy.zzz is the JWE token.
While testing in Run & Debug Xano enables you to just add the token to the header and automatically sets up Authorization: Bearer for you to be able to test quicker.
For live endpoints, be sure to properly set up the header and token.
The token should be dynamic and unique for each user per authentication.
Alternative Parameter Method There are some front-end tools that might be limited in not being able to set up headers for an API call.
Due to this, we created a get parameter to be able to pass the authorization token as a parameter in the URL.
This is a rare use case and should only be used if you are unable to use the header method.
The get parameter is as follows:
?authtoken=xxx.yyy.zzz On an API endpoint endpoint URL, for example: https://x9qk-rkcz-tbuf.n7.xano.io/api:kEw3R3wz/course?authtoken=xxx.yyy.zzz Example of Authenticated Request The /auth/signup and /auth/login endpoints retrieve a token.
Once the token is retrieved, it can be used in the header of the /auth/me endpoint to run the API endpoint and get the user record belonging to the authentication token.
For this example, we are going to sign up a new user and retrieve an authentication token.
Then, we are going to pass that authentication token into the header of the /auth/me endpoint, which requires authentication.
First, sign up a new user by entering the required input fields.
In the /auth/signup API endpoint, input the required fields to sign up a new user.
Then, hit run to run the API endpoint.
The response will return the Authentication token.
Next, copy the authToken.
Then paste it into the header of the /auth/me API endpoint, which requires the Authentication token.
If the Authentication token is accepted, then the API endpoint will run.
In this case, it will return the record that is unique to the user with this Authentication token.
Think of it like logging or signing into an app and looking at your user profile/settings/information.
In this example, the authToken was accepted and the API endpoint ran successfully returning the user record associated with the authToken.
Easy Auth Token Retrieval in Xano We made it fast and easy to grab an authentication in token without having to first run the auth/login or auth/signup API endpoints.
When opening Run&Debug in Xano on an authenticated request, there is a blue icon on the left side of the header.
Click the header to reveal to quickly grab a user in your database or search through them.
Select one and an authentication will automatically be generated.
Once the authentication is generated, the endpoint can be executed.
Additionally, a copy icon will show up on the right side of the auth token.
Click this to easily copy the entire token. | https://docs.xano.com/api/the-basics/authenticated-request |
a684eceee76f-1 | Previous Creating an API Endpoint Next Naming your API Endpoints Last modified 3mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/the-basics/authenticated-request |
b53b3a3d6ab9-0 | The naming scheme of your endpoint URLs can help you stay organized and efficient. Below are some things to keep in mind and best practices. As you begin creating and adding additional endpoints to your API, you should consider being mindful of how they are named. Your naming convention, when done strategically, can be a valuable tool that helps you and others clearly identify and understand which endpoint does what. There are a few things to know about naming your endpoint URLs. Resources and URIs
The primary data representation in REST APIs is called Resources. If Resource naming is consistent and strategic, it makes it easier to understand which API endpoint is doing what. REST APIs use Uniform Resource Identifiers (URIs) to address resources. For example, /merchants is considered the URI. Use nouns instead of verbs
You should predominantly use nouns when naming. You should not refer to any of the CRUD verbs (get, delete, post, etc.). HTTP request methods should be used to indicate which CRUD function is performed.
“RESTful URIs should refer to a resource that is a thing (noun) instead of referring to an action (verb) because nouns have properties which verbs do not have – similar to resources have attributes.” – RESTfulAPI.net Forward slashes (/) indicate hierarchical relationships
The forward-slash (/) character is used in the path portion of the URI to indicate a hierarchical relationship between resources.
*Do not use trailing forward slashes (/) as this can be confusing.* Path parameters
Curly brackets {} indicate required path parameters for the API endpoint. They are used to identify a specific resource or resources. Use lower case letters when convenient
By convention, resource names should use exclusively lowercase letters. Do not use file extensions
File extensions (e.g. .xml) do not add any advantage. If you want to highlight the media type, then you should rely on the media type as communicated through the Content-Type header, which determines how to process the response body’s content. Hyphens instead of underscores
This is mostly preference. But it is suggested to use hyphens instead of underscores as separators. This is because underscores can either get partially obscured or completely hidden in some browsers or screens. Consistency is key
Consistency is key. This will help you navigate and clearly understand what your API endpoint is doing. You should strategically approach it and consider if your naming convention would be clear to someone who’s not familiar with your application. Avoid jargon and abridging, instead use an intuitive naming scheme. Additional information:
Restfulapi.net
Nordicapis.com Error: API name is already in use You may see this message when either creating new API endpoints, or publishing drafts for existing APIs. This is because the name of the API conflicts with another API endpoint. Your API endpoint names require uniqueness to make sure that all requests end up in the right place. For example, if you have the endpoints shown in the screenshot below, you could not add a new GET /service/test because we already have /service/{id}. Xano would have no way of knowing which endpoint to send the request to. We could, however, use /service/special/test, as the name now contains additional nesting to make it unique. To resolve this message, you can do one of the following: Rename the endpoint to something completely unique Change the verb of the endpoint (for example, use PATCH instead of POST) Add nested parameters to the URL. For example, /service/byId/{id} instead of /service/{id} Previous Authenticated API Requests Next Move or Clone an API Endpoint Last modified 2mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/the-basics/api-nomenclature |
9f61408e3afb-0 | Move an API Endpoint Moving an API Endpoint allows you to move an API Endpoint or multiple API Endpoints to a different API Group. To move an API Endpoint, open the menu icon of the individual endpoint and select move. Optionally include additional API Endpoints to move then select which API Group is the destination - you can even create a new API Group on the fly. Finally, decide if you want to leave a copy of the API Endpoint in the original group. You can also bulk-move API Endpoints from the group view by selecting the menu icon on the heading of Endpoints. Keep in mind API Groups have different canonicals meaning the endpoint URL will be different when it moves groups. Move API Endpoints to different API Groups. Optionally leave a copy of the Endpoints in the original API Group. Clone an API Endpoint Cloning an API Endpoint allows you to quickly make a copy of an API Endpoint within the same API Group. Open the menu icon of an API Endpoint and select Clone. Choose a new name or leave the default name for the cloned endpoint. Choose a name and select save to clone the API Endpoint. Previous Naming your API Endpoints Next API Status Codes Last modified 4mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/the-basics/move-or-clone-an-api-endpoint |
72b32a1f754b-0 | After an API endpoint is executed, you'll usually get a status code along with the data you requested (if it ran successfully). Status codes are the same across all web services so it's good for you to know them. For Example: if you're trying to work with a weather external API service to get the daily forecast and get a 503 response, It means there's something wrong on their end. See below for all status codes Code Status Description 200 OK The request was successfully completed. 201 Created A new resource was successfully created. 400 Bad Request The request was invalid. 401 Unauthorized The request did not include an authentication token or the authentication token was expired. 403 Forbidden The client did not have permission to access the requested resource. 404 Not Found The requested resource was not found. 405 Method Not Allowed The HTTP method in the request was not supported by the resource. For example, the DELETE method cannot be used with the Agent API. 409 Conflict The request could not be completed due to a conflict. For example, POST ContentStore Folder API cannot complete if the given file or folder name already exists in the parent location. 500 Internal Server Error The request was not completed due to an internal error on the server side. 503 Service Unavailable The server was unavailable. Previous Move or Clone an API Endpoint Next - The API No-Code API Builder Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/the-basics/api-status-codes |
66f041e16a60-0 | Learn how to use the powerful NO CODE API Builder. Xano provides a No-Code API builder that allows you to build everything from simple to very complex statements. Xano automatically generates and documents CRUD operations for each table you define, but you can create your own API endpoints easily with this builder. If you haven't learned about what an API is yet, we'd recommend that you learn about it.
Link to YouTube Video: https://www.youtube.com/watch?v=i3I77GmmJxM There are three parts to Xano's NO CODE API Builder 1. Inputs
Parameters that are passed to the Function Stack from the front-end you connect to. 2. The Function stack
Function(s) that execute in a linear fashion when your API is called. 3. Response
What Xano returns to the Front-end or a connected service after it executes the functions in the Function stack. If you're looking to automatically execute Functions or API Endpoints on a given time interval, Try looking up Xano's Background Task (Cron Job) feature. Editing and Publishing your API Previous API Status Codes Next 1. Inputs Last modified 4mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/api-builder |
093f65e080a2-0 | Inputs are used to manage the Input configuration of an endpoint. Inputs are parameters that are passed from the front-end that are then used in the Function stack when your API endpoint processes. Sometimes these inputs are also called query parameters. For example, If you were creating an API endpoint to collect the entries from a signup form and store it in the database, it might look like this: An Input can be created using the same Field Types that are used in the database. In this example this API Endpoint collects: firstname as field type text lastname as field type text and email and field type email Once these inputs are defined, you're able to use them anywhere in the Function stack. How do inputs get passed into the Function stack? In the Inputs section of the documentation, we passed firstname, lastname and email as input parameters. Let's see how they're used in a function in the function stack As you can see, there's a single function called Add Record which adds a single record to a given table. In the above example, it's adding to the user table. Let's see how you would use the Inputs being collected in this function: As you can see, the Add Record function shows the database table columns on the left-hand side, and you can map it to anything you want on the right. In this case, we want to map it to the firstname input we're collecting from the front-end, so we can select the input on the right and select the input we want to be mapped to the database column. Testing your inputs Once you have your functions mapped, you can always test your Inputs by using Run & Debug and you'll see a section where you can enter the inputs on the right: Are my inputs limited in size? Currently, at this time, we can not process more than 10KB in a single request unless you are on an Enterprise plan. The API - Previous No-Code API Builder Next 2. Function Stack Last modified 4mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/api-builder/inputs |
072b030ba126-0 | The Function Stack is the internal workings of the API. The Function Stack is a "stack" of Functions that get executed in a linear fashion. They determine how an endpoint gets processed. The Function Stack is where you will build your business logic. You can add a variety of functions and get as complex as needed. You can watch the Functions video where we touch upon them. There are a series of functions you have access to broken up into these categories: Database Requests (Functions for accessing the Database) Data Manipulation (Variables, Conditionals, Loops, and more) Data Caching (Caching powered by Redis) Cryptography (RSA Keys, JWE Encode/Decode) Custom Functions (Functions created by you or installed by the Marketplace) Utility Functions (Stop & Debug, Random Number, Preconditions) Content Upload (Images/Files/Media) External API Request (Connect to any External API Endpoint. Import Curl) The Inputs section should have given you a good understanding of how inputs are passed into the function stack, now let's talk about how data is passed from function to function. How does data get passed through the function stack? Each function stack item typically returns a Variable that you can they reference in subsequent functions in the function stack.
Link to YouTube Video: https://www.youtube.com/watch?v=w6kMyLVEqeo How do I add a function to the Function Stack? To add a new function to the Function Stack, click on the "+" button in the top right-hand corner of the Function Stack or below an existing step in the stack. After hitting the "+" button the window below opens up. There are a variety of options to choose from. Within each option, there are a variety of Functions you can add depending on what business logic you'd like to introduce. Adding logic or conditions to specific Functions Sometimes you need to specify rules when using functions like Conditionals or Preconditions or when you filter the type of records you want in a Query All Records function. Xano has a flexible Expression Builder that you'll be using to do this. Moving or re-ordering functions You can move or re-order function easily by clicking the drag handler to the left of the function How do I comment out (hide) a Function in the Function Stack? Commenting out a Function can be a handy feature to utilize, especially when building complex business logic in the Function Stack. Commenting out the Function means that the Function will essentially be hidden and ignored when running the Stack. This is more advantageous than deleting the Function because the Function is saved and you don't have to start over from scratch. To hide or comment out a Function, hover over it. Once it's hovered over, an icon of eye will appear. Click on that icon to comment out the Function. The icon will update to be slashed through and the Function will be shaded dark, indicating that it will not be executed. Multi-Select You can hold Shift and drag to select multiple functions in your function stack to group, disable, or delete multiple functions at once. Previous 1. Inputs Next 3. Response Last modified 4mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/api-builder/function-stack |
7f39f8317fbd-0 | This is the output of the API. The Response specifies what you're returning to the front-end or any service you're connected to. In the example below, you can see that after this API Endpoint executes, it's going to return the variable newuser . If we Hit Run & Debug, this is what the user variable might look like: You'll notice in the response section that the return type is as self : This simply means that it's going to return the newuser variable as it's own object without being labeled anything. You can change the return to anything you like as shown below: If you want to add more variables from the function stack to your response, you can simply click the plus button to do so: Previous 2. Function Stack Next The Expression Builder Last modified 4mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/api-builder/response |
44f683a84163-0 | The Expression Builder is used to configure what expression the API checks.
You can configure your expression based on the different columns of your database table or compare different variables.
The left side of the configuration is the column/variable/value you would like to use.
The middle part is the operator where you can select: equals, does not equal, greater than, greater than or equal, less than, less than or equal.
The right side is the value that you want to compare the left side to.
Here is an example of an expression: In this example, we are checking to see if a user's email is equal to a specific value in a custom query.
If you are using the expression builder in certain functions, you also have access to a special variable called $this to focus on the specific element and any data inside it.
We can make more complex expressions using additional conditionals.
Clicking on the blue plus button adds more options like "And", Or", "And()", "Or()".
"And": adds to the expression where it must match all of the conditions.
"Or": adds to the expression where it must match either of the conditions.
"And()": adds to the expression where it must match all of the conditions as well as allowing the user to add an additional set of conditions that are wrapped within the parenthesis.
An example, of this would be: and( $this < 100 and $this > 30), so this would find any element that is between 30 and 100.
"Or()": adds to the expression where it must match either of the conditions as well as allowing the user to add an additional set of conditions that are wrapped within the parenthesis.
Additional filtering can be added to the left or right side depending on the Data Type.
Operators Equals (==) - an exact match Not Equals (!=) - does not equal Equals with type matching (===) - an exact value match and an exact type match Ex.
Variable var_1 has a value of 123, with a type of text.
You set up a conditional statement to check if var_1 === 123, but your value in the conditional statement is of type integer.
This would return false, because the types do not match.
Not equals with type matching (!==) - does not equal value or type, similar to === Greater than (>) - the value on the left is greater than the value on the right Greater than or equals (≥) - the value on the left is greater than or equals to the value on the right.
Less than (<) - the value on the left is less than the value on the right.
Less than or equals (≤) - the value on the left is less than or equals to the value on the right.
Query Operators LIKE - Used for comparing text.
Like is case-insensitive and compares if a text string is like another text string.
It can be thought of as equals for text but upper case and lower case does not matter.
NOT LIKE - Used for comparing text.
Not Like is case-insensitive and compares if a text string is not like another.
It is like not equals for text but upper case and lower case does not matter.
INCLUDES - Used for comparing text.
Includes is a flexible operator and is case-insensitive.
It is able to determine if there is a partial match in a text string.
DOES NOT INCLUDE - Used for comparing text.
Does not include determines if a text string is not included in another text string.
IN - If a single value is found in an array (list).
Start with the single value on the left side and the right side should contain the array.
NOT IN - If a single value is not found in an array (list).
The single value should be on the left side and the array on the right side.
REGEX MATCHES - Regular Expression used for finding patterns in text. | https://docs.xano.com/api/api-builder/configure-an-expression |
44f683a84163-1 | REGEX DOES NOT MATCH - Regular Expression used for finding a pattern that does not match in text.
OVERLAPS - Used for comparing two arrays.
Overlaps determines if any values in one array are present in the second array.
DOES NOT OVERLAP - Used for comparing two arrays.
Does not overlaps determines if no values in the first array are present in the second array.
CONTAINS* - Contains is an advanced filter used for JSON and arrays.
It looks for an exact schema match.
DOES NOT CONTAIN* - Does not contain is the opposite of contains.
It determines if there is not an exact schema match.
Query Operators become filters in Expression Builders outside of the Query All Records function (Conditionals, Array functions, etc.).
The filter can be applied and the expression set to equal (or not equals) a true or false boolean.
*The contains filters are different than the contains operators.
Previous 3.
Response Next - The API Editing & Publishing Last modified 3mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/api-builder/configure-an-expression |
03afdbd66e79-0 | Xano allows you to easily edit and test your API before publishing changes live. Edit your API and test the changes before publishing means you can make edits in a draft of your API without affecting what's live. Drafts recognize and record each micro-change on an individual API (or Background Task, Addon, or Function) so you can revert any changes while editing. You can test the changes in the draft with Run & Debug, and once satisfied publish the changes. This is different than Branches because Branches allow you to work and edit in a copy of your entire business logic (API, Background Tasks, Addons, and Functions) that is entirely separate from your live version. With Branches, you can instantly switch back and forth on which Branch you want to be live.
Link to YouTube Video: https://www.youtube.com/watch?v=Yh5dHwysbkg Editing your API Creating a Draft Once you start editing your API, a draft will automatically be created. Drafts keep track of each micro-change you (or your team members) make to a Function Stack called Revertible Changes, which you can easily roll back. Revertible Changes Revertible changes show each micro-change, when they were made, what the change was, and who made it. To revert a change, select the change you wish to revert back to. You can also revert all changes to revert all changes in the draft and return to the original version of the Function Stack. Testing a Draft Testing the API with Run & Debug will use the draft you are editing while calling the API from the front-end will use the live (published version) of the API. If you have other drafts across your workspace that may interact with the current API or Function Stack you are editing, you can include the relevant drafts while testing in Run & Debug. Optionally include relevant drafts during Run & Debug. Publishing Once you're ready to publish the changes, you can simply select publish. You can include a description of the changes you are publishing. Additionally, you have the option to publish other active drafts in your workspace. This might be useful if you are working with multiple workspace objects that interact or depend on one another and need to be certain everything works harmoniously before publishing. Optionally include a description of the published changes. Also, you may publish other drafts in the workspace at the same time. Once a draft is published, the changes will become live. Meaning if the API endpoint is called from a front-end, the changes will be reflected. Publishing a draft will create a Schema Version of the API Endpoint, which allows you to roll back to previously published versions. How do I know if I have drafts to publish? You can see drafts available for testing and publish via the Publish dialog on any of your function stacks, or in a notification on the dashboard. If you find that you have made changes but are not seeing the expected results via your front-end, ensure that you have published these changes. Previous The Expression Builder Next - The API Testing your API Last modified 4mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/editing-and-publishing |
ea5d2f1c4608-0 | Run & Debug You can test your API using Run & Debug. It's a powerful tool that can be used on your Function Stacks to verify whether or not they are working properly. It can be found on the top right-hand corner of any API, Function, Addon or Task. Example Request The above screenshot shows an API endpoint that takes a Star Wars planet name and returns information about the planet using the Star Wars API (swapi.dev). They don't have an API that searches a planet by name so this function stack has to recursively loop through the returned planets and match up the user's request. Want to learn how to build the Star Wars Planet finder? Watch the tutorial! Step 1 - The "Include variable details during run" toggle This option allows you to store all the detail of how your API request was run. This is very helpful for debugging what was returned by each individual function as it was executed. If you are running requests that produce large amounts of data, it can cause delays during Run & Debug. It can even cause the API Test to completely stall out if the payload is very big. Step 2 - Press Run and wait for a response Depending how the nature of the business logic in your function stack, the response could happen very quickly or take time to execute. A countdown timer will show as soon as Run is pressed. Here's an example of what the response looks like in our Star Wars API example: A. The Result/Response This will show what the API is returning. In this case, it is a successful response so we see the object of the different planets coming back from the API. If there was an error, the status code and associated message would be displayed. B. Result Summary This contains three relevant pieces of information The Status of the request. In the above example, it reads success because it received a Status code 200. If there was an error, it would display a red box with either the error or the status code: Statements - Statements represent each individual action that took place in the function stack. In the above picture labeled B2, notice that there are three (3) functions in the function stack. If you look at that Result, however, there are 14 total statements. This is because there is a for each loop that iterates over the results coming back from the API causing more statements than functions. Runtime - Shows how quickly all of the statements were executed. Regardless of status, you're able to copy the result to the clipboard by clicking on the copy icon. C. The Debugger When the Function stack is executed within Xano, you'll be able to see the response time of each statement that was executed Using the Debugger A. Inputs & Environment Variables Inputs & Headers - Displays any inputs or headers that were defined Env - Any Environment variables used . B. More information - Click to expand for more detail. C. Statements - Tells you each function that got executed and its associated runtime. This is very helpful in helping you diagnose what happened during each statement execution. D. Statement detail - You can expand the details of any statement to see the inputs and what is being passed along to the subsequent statement. The API - Previous Editing & Publishing Next - The API Webhooks Last modified 4mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/api-debugger |
fc490ca45c00-0 | Webhooks are a simple way that an app can send an automatic message or payload of information to another app. It's the method that Stripe might use to notify you when a payment has come in, or how a support bot like Intercom notifies you about new requests in your Slack. Simply put, Webhooks are ways for your online accounts to "speak" to one another and get notified automatically when something new happens. You'll need to know how to use webhooks if you want to automatically push data from one app to another. How to set up an API endpoint to be a Webhook Webhooks always use the POST API Verb since the other services are "Sending/Posting Data" to your Webhook endpoint. In order to receive the response from a webhook, the very first function in your Function stack should be Get All Input as shown below. How do I preview the response from a Webhook? You can use the Request History to see the response of a Webhook. This is important to do because it will help you create the logic in your function stack based on the data being sent. You can see how to access the Request History to view the response of a Webhook in the tutorial below. A practical example of how to use a Webhook with Typeform
Link to YouTube Video: https://www.youtube.com/watch?v=D4ZDHId2CnE The API - Previous Testing your API Next - The API API Request History Last modified 4mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/webhooks |
3295c76acbf4-0 | See your incoming External API Requests in Xano From the dashboard, easily view the high-level statistics of the API request history from your entire Workspace. You can toggle between your database and top API requests to see which of your API endpoints are being hit the most. To the right, visualize your API request history with a graph displaying the statistics of the past 24 hours. Select 'View Request Details' to see a detailed view and history of each API call made in your Workspace. You can expand each individual call to review detailed information including inputs, response and request headers, and the output. You can even drill-down on a per-user basis to see the activity of each user in your application. Furthermore, you can view failed API calls here in order to help debug what went wrong. Finally, you can use these details to understand Webhook payloads to make it easier to build API endpoints that receive Webhooks. It doesn't stop at the entire Workspace level. From each API group, you can see the detailed history of the entire group. And from each API endpoint, you can see the history of the individual endpoint. The API - Previous Webhooks Next - The API Auto-Documentation Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/api-request-history |
735b90b45681-0 | Xano uses Swagger to automagically document your API! Every API Endpoint in Xano is Auto-documented Xano automatically documents all your API endpoints in Swagger. This way, you can pass the document to any front-end engineer or stakeholder that might want to see your API without giving them access to your Xano workspace. Within the Swagger documentation, you will be able to test and try out your API endpoints to see if they work the way that you expect them to. Let's open the POST /lesson API and see what it looks like. After clicking "Try it out" we can click on the "Execute" button, which will use the API to generate a new lesson record. Swagger will show any errors that can come up when running an API. API Spec Swagger also provides you with an API specification URL. Select this from the top of your API documentation to open up the API specification. This can often be helpful for getting a broad understanding of how your API works and how different endpoints interact and relate. Select the API spec link to see the API specification. API Spec in JSON By default, the API Spec is in a YAML format. However, JSON format is supported. In order to view the API Spec in JSON, append ?type=json to the spec URL. Append ?type=json to see your API Spec in JSON format. Disabling Swagger Documents You are able to disable Swagger documentation on an API group level. To enable or disable the documentation head to an API groups settings. The API - Previous API Request History Next - The API Branches & Merging Last modified 2mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/auto-documentation |
a3f390d88e4c-0 | Branches are used to develop and test new versions of your Business Logic and API.
You can Merge Branches for seamless development workflows.
You can create new Branches and select which Branch to make a copy of, choose which Branch to make edits to, and select which Branch you want to be live for your API.
Branches can also merge from a source Branch to a destination Branch to make managing development, test, and live environments as seamless as ever.
Link to YouTube Video: https://www.youtube.com/watch?v=3qwu_ANWHl4 Branches tutorial before merge capabilities were introduced.
Your initial Branch will be considered v1 of your business logic.
Below your workspace name, you will be able to identify which Branch you are currently editing.
Automatically, you will start on v1.
Create a New Branch Select the Branch identifier located underneath the workspace name.
This will allow you to see and change which Branch you are currently editing and which is live for your users, and allow you to add a new Branch.
When you select Add new Branch you will be able to choose a source Branch to make a copy from, the name of your new Branch, and a description.
Adding a new Branch makes a copy of the source Branch at that given time.
So for example, if you create v2 from source Branch v1, you will have all the same business logic (APIs, Functions, Addons, and Tasks).
Change which Branch to Edit and Set Live The Branch you are currently editing will be identified underneath the workspace name on the left menu column.
To change this, click on the Branch name to open up the menu of the different Branches in your workspace.
Select a Branch you wish to edit or set live and you will have the option to do so.
Edit or Set Live a Branch.
When a Branch is set live, it is the Branch or version of your API endpoints and business logic that will be live for your users.
If you wish to call an API endpoint from a Branch that is not live, you can do so by adding the branch name after the canonical, for example: If the live branch is: https://xb17-511e-40b9.xano.io/api:b4afb8/tutorial You can access a different branch by adding :branch name after the canonical: https://xb17-511e-40b9.xano.io/api:b4afb8:v2/tutorial You can also use a Set Http Header function, to set the X-Branch header followed by the Branch name.
For example: X-Branch: v2 Setting this on an API endpoint would force that endpoint to call the v2 Branch version of the endpoint.
Know if the Branch you're editing is Live or not While making changes in your workspace, you can differentiate if your Branch is live or not with the color of the Branch name in the left menu column.
When the Branch name is blue, the Branch is live: v1 is Live.
If the Branch is yellow, it is not live: v2 is not live When editing a Branch that is not live, the Swagger documentation and API Endpoint URL buttons will provide the version of that Branch and not the live Branch.
To get the URL of the live Branch either remove the :branch name after the canonical or go to the live Branch.
Merging
Link to YouTube Video: https://www.youtube.com/watch?v=-sqCQBN0z_Q Merging Branches allows for seamless development management of different environments.
It allows you to update a destination Branch with changes and updates created from a source Branch.
Merging will include changes to published objects such as APIs, Functions, Addons, and Tasks, and newly created ones.
For example, your live Branch is v1.
You are editing v2, which has some new API endpoints for a new feature you are rolling out. | https://docs.xano.com/api/branches-and-merging |
a3f390d88e4c-1 | During the development phase of v2, you had to modify an API endpoint in v1.
When you're ready to merge v2 into v1, Xano will add the new API endpoints from v2 and maintain the update to the API endpoint on the destination v1 Branch.
How to Merge To merge Branches open the Branches menu by selecting the Branch name under the Workspace name in the left-hand navigation bar.
Open the Branches menu.
Next, select Merge Branches.
Select Merge Branches.
After selecting Merge Branches, Xano will ask you to select the source Branch.
The Source Branch is the Branch containing the updates and modifications that you want to merge into the Destination Branch.
Choose the Source Branch - the Branch with new changes or updates.
Next, select the Destination Branch to merge the changes from the Source Branch.
You can also choose if you would like the destination branch to be backed up prior to the merge.
The Destination Branch is the Branch where the updates will be merged into.
Select the Destination branch, and if you want the destination branch backed up before the merge Then, Xano will display a confirmation page with all the Workspace objects receiving updates or new items.
If there is a change you do not want to include in the merge, select the settings icon next to the Workspace object and deselect the change to remove it from the merge.
Edit what's included in the merge.
Deselect specific changes to remove from the merge.
Once satisfied with all the updates included in the merge select publish to merge the Branches.
Select Publish to merge the Branches.
Restoring a Branch Backup
Link to YouTube Video: https://www.youtube.com/watch?v=AbXCEq4U_VY If after you have merged branches, you would like to restore from a backed up branch, click on the branches option, and check the "Include Backups" checkbox.
This will show you all available backups, which you can then click and edit or set live just like any other branches.
Setting live the backed up branch will allow you to quickly roll back to before the merge was made.
Use the Include Backups option to show backups made during branch merge.
The API - Previous Auto-Documentation Next - The API API Performance Last modified 3mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/branches-and-merging |
14bfa6bb1487-0 | Xano does a lot of work behind the scenes to ensure your API response time is as fast as possible. That said, there are best practices that should be followed when you're building your API endpoints to avoid slowing down your server. What is "good" performance? The performance of your API endpoint depends on a number of different variables which include: The complexity of your function stack and the number of statements that execute How much data is being processed How your Database is set up/indexed (if you're querying the Database) Server location and resources Examples below are using a Xano paid plan (Dedicated resources) with a local server: The below response times will change depending on your Xano plan and load on your Xano Instance. Task Statements Median Response Get 100 Records 1 < 1 second Filter 100,000 records by one field 1 < 1 second Bulk Add 10k records 1 < 1 second Transform 100k records (Change field to uppercase) 3 < 1 second Bulk Delete (Recursive) 502 < 5 seconds *< 1 second = under 1 second **The results are the median response times between Launch, Scale, and Scale-2x. How to improve your API response times Get a dedicated instance in a region that's closest to your customers
The Build (FREE) plan is on a shared resource. When you upgrade, each paid Xano instance is on dedicated resources and allows you to deploy in the region of your choice. The closer the server is to your users, the faster the response time will be. Xano uses Google Cloud under the hood so if you don't see a region that is listed on their supported regions page, please contact support. If there is enough demand, we will open a new region. Optimize Database Performance
There are many ways to set up the Database for your application. Unfortunately, there are inefficient ways to set this up that can slow your app down. You'll have to go through a few iterations to find the most efficient way for your use case. Simplify your Function Stack
This may seem obvious, but producing a response in ten (10) functions is slower than doing it in three (3). It's also important to remember that the number of functions in the function stack could be different than the statements that get executed. Use Addons when requesting related data
Addons are Xano's way of enriching the response of a Database query without a heavy volume of requests. As a simple example, let's say you want to get 100 unique books and their associated 100 unique authors. Normally that would be 101 requests (1 request for all books, and a request to retrieve each author). With the magic of Addons, it's only 2 requests (1 to get the books, 1 to enrich the authors). Use Data Caching
When working with large datasets or external API endpoints that have a rate limit/cost associated with them. (request caching, function caching, redis caching). Use the Stream return type when looping through large sets of data. This will retrieve your records in a memory-efficient way. Troubleshoot a slow API response. The API - Previous Branches & Merging Next Troubleshooting Performance Last modified 3mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/api-performance |
7cbbc409ec99-0 | An introduction on how to find the cause for performance concerns, and what to do about them.
When every request feels slow Step 1.
- Check if your server is being overloaded with requests A.
Look at Instance Usage - When you log into Xano, the Instance Dashboard will reflect where there might be a usage spike based on your capacity.
This is a near real-time graph (delayed by a few min) of the last 24 hours.
Ideally, you want to keep things below 50% at all times, but if you aren't on the appropriate Scale plan, usage spikes could push your Database and API capacity up.
If Database usage is high - When the Database (blue) request line is high as shown above, this usually means that your Database is not optimized or indexed properly.
Please visit the Database performance section to look at ways to fix the tables that are being queried.
Usually, API usage goes hand-in-hand with Database usage, so it isn't surprising to see them at the same level in the above example.
Once fixed, you should see both Database and API usage go down.
If API usage is high - When the API usage is high on its own, this usually indicates that there is a traffic spike and your server is running out of capacity.
This normally happens when multiple users are trying to request data from your API at the same time.
You can increase your capacity by upgrading to a different Scale package.
While we do obfuscate this somewhat as a No-Code platform, remember that your Xano instance is a server, which is just a computer like any other.
Your usage does not necessarily have to hit 100% usage to be considered "maxed"; as load increases, performance can decrease even if the increase does not seem significant.
If you need hands-on private help diagnosing this, you can schedule a premium support call with one of our Xano team members.
B.
Instance Stats You can see the volume of requests happening across all your workspaces here.
This is also across a 24-hour window and is updated every hour.
If you see a large volume of requests as pictured above, proceed to step 2 to see where it's coming from.
To dig deeper into the details of each request, you can proceed to Step 2 below.
Step 2.
Look at the API requests for each workspace Each workspace has a dashboard item of request history.
Click DETAILS at the top right of the graph to see each request.
A.
You can filter down the requests that are taking the longest.
Select the magnifying class to do this.
A good rule of thumb is to select requests that are greater than 5s.
B.
You can click the refresh button to ensure you're getting the latest data.
C. Click on the request that takes a long time to show the details.
How to diagnose a slow API endpoint When a single API Endpoint feels slow 1.
Look at the response times in the Debugger Start by finding the API endpoint that is causing issues.
When the Function stack is executed within Xano, you'll be able to see each statement's response time.
Example This API endpoint takes a Star Wars planet name and returns information about the planet using the Star Wars API (swapi.dev).
They don't have an API that searches a planet by name so this function stack has to recursively loop through the returned planets and match up the user's request.
Debugging the screenshot below A.
There are technically three (3) items in the function stack.
B.
After you click Run & Debug, click the debugger tab to see the results and response times.
C. You'll see that while there were only three functions, 14 statements got executed.
This is because Function 3 is a For Each loop that goes through each result of what is returned by the API and creates a variable. | https://docs.xano.com/api/api-performance/troubleshooting-a-slow-response |
7cbbc409ec99-1 | D. You'll see that the total response time is 5.39s which is quite long for a response, however you can also see in Line 1 of the Debugger that the Star Wars API request is taking 5.37 seconds to return a response.
Xano's execution of the request happens much faster.
If you have already addressed efficiency concerns in your database and function stacks as detailed in how to improve your API response time, the next step is to upgrade your Xano plan for improved performance.
When Compute is Low, but Performance Still Suffers This is an edge-case scenario, where all of the following are true: Your API compute is very low (less than 30%).
Your DB compute is very low (less than 15%) You are not querying large tables (typically 10,000 records or higher) You are still experiencing one or more of the following: Slow API responses Trouble accessing or working in Xano When this happens, this can mean that you have exceeded the running memory (RAM) limits of your current plan.
This is not a typical scenario, but can still be addressed by exploring one or more of the following: Check the amount of APIs, functions, addons, and tasks you have.
The more you're asking out of your server instance, the more power it needs to ensure everything can execute in a proper and timely manner.
It is possible to have "too many items", which can cause some of the issues described above.
Reduce the amount of these items in your workspace and try again.
Check your table schemas While it may seem strange that, as an example, a table with 100 records is taking an extended period of time to query, the number of records is not always the contributing factor.
If this table with 100 records has over 150 fields (this is just an example value), this increases the query time on that table.
Reduce your table schema by potentially offloading some of that data into a new table.
Contacting Support If you are experiencing slowness with Xano and can't figure it out on your own, you can contact support.
Please carefully read the following to resolve your issue as streamlined as possible.
Have you tried the debugging steps listed above to narrow down problematic requests or steps in your function stack?
If you are having an issue on your front-end, have you taken the necessary steps to ensure that everything is set up correctly on your front-end to use external data sources (like Xano)?
Have you consulted the Xano community and the documentation on this issue?
If you have taken the steps to troubleshoot your endpoint, please make sure that you prove the following information when contacting support.
Please be sure to read and understand support expectations around these types of issues.
Please provide the following details: Workspace name API endpoint/function/task that is slow (please include the URL in your address bar) JSON payload, if you are passing data Email or user ID, if authentication is required Screenshot of your usage graph and API request graph Other helpful information (describe the issue in detail), for example: Is this always slow?
intermittent?
Is this endpoint returning records?
If it is, how many records is it returning, and does the amount of records seem high for what you are expecting or is it normal?
If you do not provide all of the information listed above, your support request will likely receive a delayed response Example Support request Workspace name: Example
API endpoint: https://x07d-e032-f135.n7.xano.io/admin/workspace/1/api/2/query/13
JSON data payload: {"test": "hello there", "value": 123}
Authentication: Yes - user: [email protected]
Additional information and description of the issue:
"This API endpoint seems to always be unusually slow.
I'm experiencing a response time of x seconds.
The endpoint is returning 25 records and the response looks to be correct. | https://docs.xano.com/api/api-performance/troubleshooting-a-slow-response |
7cbbc409ec99-2 | Let me know if you need any additional information" How do I find all this information?
Workspace name: You can find the name of your workspace at the top of the navigation bar.
API Endpoint URL that is slow: JSON data payload (if you are passing data to the API endpoint): Please provide a valid JSON payload if you send data to the endpoint.
User ID or email address (if the endpoint requires Authentication): Please provide a valid user ID or email address if the endpoint requires authentication.
You can retrieve that information from the user table or on the API endpoint like so.
What to Expect Due to the complex nature of these requests, it can take an extended period for us to work together with you to diagnose and resolve these issues.
Expect to budget at least two to three weeks to support these specific requests.
We do have priority support packages available if this is not sufficient for you.
The team will review with you the actions you have already taken as detailed in our above, and make any recommendations for additional efficiency.
Please understand that every Xano plan has its limits, and our ultimate recommendation may be to upgrade to a higher tier plan, but we will do everything we can to address outstanding issues before this.
Is there anywhere else I can get help?
We understand that sometimes waiting isn’t an option.
There are multiple other avenues that you can take to get support with Xano.
The Xano Community (community.xano.com) Xano Development Partners - We have Xano partners that we can connect you with if you would like direct help developing in Xano.
If you would like to enlist a Xano Development Partner, please fill out this form.
Connect With Xano Experts - Create a post in the Find an Expert category of the Community.
Some members of the Community have a Trusted Xano Expert title.
These members have been recognized by the Xano team to give great advice and support, however, they are not directly affiliated with Xano.
These members may provide paid support services, which are also not affiliated with Xano in any way.
The API - Previous API Performance Next - Working with data The Basics Last modified 1mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/api/api-performance/troubleshooting-a-slow-response |
e2c420d928d4-0 | Xano allows you to ingest, manipulate, transform and display data any way you desire. The true power of Xano is its ability to allow you to ingest, manipulate, transform and display data any way you desire. In order to make the most out of Xano, there are a few basic concepts that are important to understand.
Link to YouTube Video: https://www.youtube.com/watch?v=VfpzD134zBs Functions You can think of a Function like an action. A function can also contain a series of other functions (or actions). They range from things like Query all Records which performs the action of "Get all data from a Database table and return it ." to External API Request which performs the action of "Get data from an External API and return it". Xano has many pre-built functions Variables Variables are one of the most important concepts to understand in Xano. You can think of Variables as containers that hold information. Their sole purpose is to label and store data in memory to be sent to your front-end or used in another function. Dot Notation Dot notation lets you quickly access specific properties in a given variable. For example, if you had a variable called car and it was an object that looked like {"model": "toyota", "year":"1988}, You could access the car's model by simply typing car.model . This would return toyota. You will use dot notation quite a bit to access or manipulate data in the Function Stack. Filters Filters allow you to transform and manipulate data in the Function Stack. Filters work really well with Functions because you might pull a result from a Function (like Query all records) and use Filters to dynamically transform each record before returning it to the front-end. A good example might be "capitalize the first letter of each name in the user table before returning it to the front-end " and to do this you would use the to_lower Text filter on the table.name field. Another common use case is replacing a piece of a URL (www.api.com/{replacethis}). For this example, you'd use the sprintf filter Addons (Like GraphQL) Addons are a unique and easy way to enrich the response from a single API endpoint with additional data from other database tables. Addons were created to make it easy to get the data you need without performing multiple API requests. If you’ve used GraphQL before, Addons are very similar except they offer more control over how data is queried. Dates & Times The important thing to know is that Xano stores timestamps as a UNIX timestamp in milliseconds and Unix timestamp is a way to track time as a running total of seconds. Working with Dates & Times can be confusing because there are so many different timezones and ways to display the date and time to the front-end but our documentation will tell you the differ Previous Troubleshooting Performance Next - Working with data Variables Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/working-with-data/basics |
32bb90e8976a-0 | Variables are containers that hold information.
Their sole purpose is to label and store data in memory to be sent to your front-end or used in another function.
Variables are one of the most important concepts to understand in Xano.
You can think of Variables as containers that hold information.
Their sole purpose is to label and store data in memory to be sent to your front-end or used in another function.
Variables can be stored as different types and are represented in orange in the function stack.
Here's an example of a variable being returned from a Query all Records function: The company variable that gets returned might look something like this: [ { "id":1, "created_at":1617150333684, "name":"Xano" }, { "id":2, "created_at":1617150415014, "name":"Google" } ] So if you were building an app that was displaying companies from your Database and this was sufficient, you would set this variable company to be returned as the API response.
As stated in the Function Stack section, Variables are passed through each function in the function stack.
So in the example below you can see variables being passed through the stack: How do variables work in the example above?
The above Function Stack goes through each item in the variable company using a For Each Loop and creates a new variable called individual_company to represent each company in the company variable.
There is then a Conditional function that uses dot notation to access the individual name of the company (individual_company.name) and says that if the Company name = Xano then create a new variable called success_message that says "Xano is amazing!"
Variable Types Text Text is the most common and flexible field type.
You can store anything from short names, to long paragraphs of text with emojis.
You can even store raw HTML.
Array An array is an order collection of items that can be iterated through like ["dog", "cat" , "bird", ...] Object An object is a collection of properties with key: value pairs.
If we take a car for example an object might look like: { "make": "honda", "model: "civic", "year": 2005, "color": "black" } Integer The integer field type is specifically designed to hold numbers without decimals like 1, 2, 3 or -1, 2, 3.
Decimal The decimal type is when you really want to be specific and store numbers defined by its precision.
Like Pi - 3.14159265... Boolean (True/False) A boolean value is either true or false.
This sets a definitive boolean value of true.
Timestamp (Epoch) Timestamps are stored as a unix timestamp in milliseconds and we've written extensively about how to use timestamps in Xano.
In the input box if you specify NOW, it represents the time it is when this function is executed.
Null A NULL value is a special marker used to indicate that a data value does not exist.
In other words, it is just a placeholder to denote values that are missing or that we do not know.
Input vs Defined Variables Any inputs created in your function stack will behave just like variables you define using the Create Variable function.
Environment Variables $http_headers These headers are used to pass information between the front-end calling your API and your backend.
$remote_ip This is a special environment variable that resolves to the IP address of the individual accessing the API Endpoint.
$request_uri This is a special environment variable that contains the URI that is being accessed from the API.
$request_querystring This is a special environment variable that contains the query string of the URI that is being accessed from the API.
$datasource This is a special environment variable that contains which data source is being used.
Adding Custom Environment Variables Add Environment variables to your Xano Workspace to have them accessible everywhere. | https://docs.xano.com/working-with-data/variables |
32bb90e8976a-1 | This is the safe way to store sensitive API keys or identifying information so you don't have to hard code it into any API endpoint that you do.
Using Variables with Filters There are several filters available that can be useful when working with variables.
While we have our filters documented in detail here, let's go over a few of the most popular in relation to variables.
GET - This filter is essentially a replacement for dot notation that allows you to specify a default value if the value you're storing in a variable does not exist.
For example, if I have an API response, and I want to create a new variable based on a value of that response, but sometimes that value does not exist, I would use the GET filter to provide a default or null value if that occurs.
SET - This filter is used to set a specific value inside of an object variable.
For example, if I have an object variable that looks like this: { "product": "name": "My Product" } and I wanted to add a description, I could use the SET filter to set the path of 'description' inside of 'product'.
SPRINTF - This filter allows you to substitute test with your variables, similar to the replace filter, but with a little more control over enforcement of what can be used as replacement text.
We recommend reading the dedicated documentation section for more useful filters.
Working with data - Previous The Basics Next - Working with data Dot Notation Last modified 3mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/working-with-data/variables |
d2ddea18f006-0 | Dot notation allows you to access specific fields or data nested within a variable.
Dot notation is a general programming concept and it is also a useful tool in Xano.
You can apply dot notation on any input/value line within the Function Stack or Response - whether that be within Functions or Filters.
Watch the tutorial to understand important rules and concepts around dot notation in Xano.
Link to YouTube Video: https://www.youtube.com/watch?v=kXV5bVtxW_M Using dot notation Dot notation must be used on an existing variable in Xano.
Let's use the variable car as an example.
Below you can see that 'car' is data retrieved from a database table with a Get Record function.
The response shows us the contents of the variable - all the fields and data.
The variable car being returned in our response.
Let's say we want to retrieve just the make of the car variable.
For this we can use dot notation to do so.
**It's very important to make sure the data type, as signified on the top of the input/value line is var: any (this signifies we have a variable data type selected).
** Once the variable is selected, add a '.'
after the variable name and type out the field name of the data you wish to retrieve.
**Spelling must be an exact match** In this new variable, we are using dot notation on the 'car' variable to retrieve the 'make' of the car by writing 'car.make' If we return the new variable make of car we will return the value of car.make, which is "toyota."
'car.make' = toyota Using dot notation with Lists (Arrays) Using the same example from above, let's say we have a Query all records function that queries all records from the car database table and returns an array of 3 cars stored in the variable car.
It will return a large payload that looks something like below: [ { "id":4, "created_at":1632268901955, "make":"honda", "model":"civic", "year":2002, "maintenance":[ { "year":2004, "description":"New bumper" }, { "year":2009, "description":"Radiator" } ] }, { "id":1, "created_at":1632268899571, "make":"toyota", "model":"corolla", "year":1998, "maintenance":[ { "year":2015, "description":"New enginge" }, { "year":2008, "description":"Transmission" } ] }, { "id":2, "created_at":1632268900442, "make":"jeep", "model":"wrangler", "year":2007, "maintenance":[ { "year":2016, "description":"Suspension" } ] }, { "id":3, "created_at":1632268901252, "make":"ford", "model":"4 runner", "year":2004, "maintenance":[ { "year":2011, "description":"Windshield" }, { "year":2013, "description":"Passenger door" } ] } ] Now if we only wanted to return a list of car makes without all the extra bloat, traditionally you would have to do a for each loop function and store each car name in an array in its own variable.
Luckily, using Xano's Dot Notation engine, you can easily get the makes of the cars. | https://docs.xano.com/working-with-data/dot-notation |
d2ddea18f006-1 | We can create a variable and specify car.make which will return an array of just the car makes: `car.make` = ["honda","toyota","jeep","ford"] Now when you return the variable just_the_makes It will return an array that looks like this: "`car.make`""="[ "honda", "toyota", "jeep", "ford" ] GET filter The GET filter allows you to return the value of an object at a specified path.
In other words, it's another way to use dot notation but with a filter.
You can think of the GET filter like replacing a .
in dot notation.
For example, to retrieve the make of a car instead of car.make - you could apply the GET filter to say car|GET|make The GET filter is applied to get the value of the specified path 'make' from the 'car' object/variable.
Why use the GET filter?
The GET filter has a unique advantage that can be very useful for certain use cases.
It allows you to define a default value in case the specified path does not exist.
Use cases where this may come in handy would be when calling an external API or receiving a Webhook and the returned payload can differ.
Possibly you are working with a field that is sometimes present and sometimes not.
Defining a default value with the GET filter allows your function stack to continue to run and complete the logic you are performing.
You can also use conditional logic based on a default value to perform certain logic if the specified field does not exist.
The GET filter allows for flexible default values.
Escape Sequence - Double Dot Notation While quite rare, there are occasions when a .
may be required in a path name.
An example of this is likely to come from a 3rd party API that requires a .
in a parameter name (i.e.
parameter = name.first).
Standard JSON and dot notation would treat "first" as a subpath of "name", however, in this rare example "name.first" is the entire name of the path.
To satisfy this use-case, Xano implements an escape sequence to tell the API that the .
is required in the path name by implementing a double dot or .. where required.
Example For this example, we will implement the path name "first.name" with the escape sequence.
We are able to use the escape sequence in the path to include a single dot in the path name.
The result is: { "first.name": "Michael" } The escape sequence enables us to include the .
in the path name Working with data - Previous Variables Next - Working with data Search Last modified 4mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/working-with-data/dot-notation |
ad61ab143223-0 | Leverage Xano's performant and accurate fuzzy search engine.
Xano offers robust search capabilities, commonly referred to as fuzzy search, that you can utilize while querying records in a function stack.
This includes normalization of words (ie.
party vs parties), case-insensitive support, flexible expressions (words, phrases, and negations), and weighted priorities (ie.
title vs description) for relevance.
The following demonstrates how to set up search in your database, the logic behind the search functionality, and best practices for utilizing search queries.
Link to YouTube Video: https://www.youtube.com/watch?v=5_XkvyAX2C0 Watch more videos on Fuzzy Search Creating a Search Index First, create an index.
Indexes are used to quickly locate data without having to search every row in a database table every time a database table is accessed.
An index is used to define which fields of the database table you want to search.
You can even build multiple search indexes on the same table to build different search criteria.
For example, if you have both public and private data in the same table, you can build a "normal user" and an "administrator" search.
To create an index, click Indexes at the top of the table you would like to build search for, and then click Create Index.
Choose search as the index type, and give the index a name.
Next, specify the language for the data you are searching, the fields you are searching, and the ranking order of the fields being searched.
An example of creating a search index.
In this example, we created a new search index on a database of movies called search_movies, in English, and are searching two fields in that database: title and overview.
The title field will rank higher than data in the overview field in the qualified search results.
Once ready, click Save and Xano will build your index.
This can take a few minutes depending on the volume of data of the table.
Building a Search API After generating the index, it can be implement it into a query in the function stack.
Use the Custom Query feature in the Filter tab of the Query All Records function.
When adding a custom query, the newly created index is available in the expression builder, noted by the $ symbol.
It is also labeled as search underneath the name.
Look for the $ symbol as well as the word search to easily find your search index when configuring your query.
Next, set the operator to search and specify the search query.
In this example, we are using an input called search_query.
Setting the operator to Search and specifying our search query.
Congratulations!
🥳 You've just implemented super-fast search inside your function stack.
Ranking You can implement a ranking system and sort the search results by this rank for more precise search results.
To do this, go to the Output tab of the Query All Records function, add an eval on the search index, and apply the search_query filter.
This tells Xano to "use my search index to generate a ranking score of my results based on my search query".
Create and Eval on the search index by applying the search_rank filter so we can sort by ranking.
After, add a sort to the query using the newly created eval (in this example, called "rank").
You may also consider to enable paging especially on larger queries.
Add a Sort to the Query by clicking on the Return portion of the Output tab.
Order by in descending order will provide the most relevant search results first.
Different Search Methods Search queries can be written in different ways to fulfill specific search requirements.
Words separated by a space imply an AND.
Example: A query of "toy story" means search for toy AND story Exact phrase searches are possible using double quotes.
Example: If you wanted to search for "Toy Story" as an exact match, your query would be "Toy Story" with the quotation marks. | https://docs.xano.com/working-with-data/search |
ad61ab143223-1 | Note: if you are entering this search expression directly into a JSON payload, then you may need to escape the quotes with a backslash.
example: {"search": "\"Toy Story\""} Partial phrase matching
Example: "Toy * Story" would return any results that contain Toy Story with one word in between.
"Toy *** Story" would return any results that contain Toy Story with three words in between.
Wildcard matching
Example: Sto:* would return any results that contain words that start with sto.
Expression groups
Example: (Woody or Buzz) Toy would return multiple matches for the word Toy that also include either Woody or Buzz.
Negation of specific words is possible by using a - character.
Example: If you wanted to search for movies that have Toy in the title, but not Toy Story, your query would be "toy -story".
You can also use a combination of these to get even more specific.
Example: Searching for "toy story" day -night would mean search for the phrase Toy Story and the word day, without the word night.
Priority targets allow you to specify which priority defined in your search index to use for the specific expression.
This can be combined with wildcard matching as well.
Example: Toy Story:2 would search for all records containing the word Toy, as well as the word Story in any fields representing priority 2 in your search index.
Example: Toy Sto:*2 would search for all records containing the word Toy, as well as words starting with Sto in any fields representing priority 2 in your search index.
Single vs Plural is supported.
For example, "toy" will also return results that contain "toys".
Stop Words -- are commonly used words such as articles, pronouns and prepositions.
For example: is, and, an, or, the.
Stop words are not included in your search query.
Search Results Search results are returned just like any other API response and the data works just like any other variable inside Xano.
Working with data - Previous Dot Notation Next - Working with data Functions Last modified 4mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/working-with-data/search |
d09bf41544a3-0 | Functions are organized, reusable workflows that can be easily added to any API Endpoint. Think of functions like templates or saved commands that make it easy to do the same thing over and over again.
Link to YouTube Video: https://www.youtube.com/watch?v=fQEog6BqRn8&feature=youtu.be Functions are used in the Function Stack. Stack options give you full control of your data and offer a wide array of different commands to build any custom API. Here are the Function Stack Categories: Database Requests - Functions to Query/Add/Edit/Delete from the Database Data Manipulation - Manipulate data any way you want based on logic Data Caching (Redis) - Temporarily store data or enforce rate limits Cryptography - Create keys, encode and decode data Custom Functions - Functions that you create or are installed from the Marketplace Utility Functions - Common functions that help you debug, calculate and generate data. Content Upload - Upload Image, Video, Attachment or files External API Requests - Connect to an External API Source Lambdas - Interact with and transform data using JavaScript. Working with data - Previous Search Next Database Requests Last modified 11mo ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/working-with-data/functions |
fbd7939d6749-0 | Database requests are functions that interact with the database. They allow you to manipulate the data from the different database tables in your workspace. The database request functions are: Query All Records - Retrieves all records from the database. But also, you can have full control over the queried data with filtering, joins, aggregates, response customization, and much more. Get Record - Retrieves a single record based on a field look up. Has Record - Returns whether a record exists or not based on field look up. Edit Record - Updates a record based on a field look up. Delete Record - Deletes a record based on a field look up. Add Record - Adds a new record to the database. Add or Edit Record - Looks for a record based on a field look up. If the record does not exist, it will add a new record. If the record does exist, it will update the existing record. Database Transaction - Allows you to group functions together that you want to execute only if each function is successfully executed. Typically used with two or more functions that are mission critical. Clear All Records - Permanently clears all the records from a database table. Working with data - Previous Functions Next Query All Records Last modified 1yr ago WAS THIS PAGE HELPFUL? | https://docs.xano.com/working-with-data/functions/database-requests |
End of preview. Expand
in Dataset Viewer.
No dataset card yet
- Downloads last month
- 6