Xano Documentation
  • 👋Welcome to Xano!
  • 🌟Frequently Asked Questions
  • 🔐Security & Compliance (Trust Center)
  • 🙏Feature Requests
  • 💔Known Issues
  • Before You Begin
    • Using These Docs
    • Where should I start?
    • Set Up a Free Xano Account
    • Key Concepts
    • The Development Life Cycle
    • Navigating Xano
    • Plans & Pricing
  • The Database
    • Designing your Database
    • Database Basics
      • Using the Xano Database
      • Field Types
      • Relationships
      • Database Views
      • Export and Sharing
      • Data Sources
    • Migrating your Data
      • Airtable to Xano
      • Supabase to Xano
      • CSV Import & Export
    • Database Performance and Maintenance
      • Storage
      • Indexing
      • Maintenance
      • Schema Versioning
  • 🛠️The Function Stack
    • Building with Visual Development
      • APIs
        • Swagger (OpenAPI Documentation)
      • Custom Functions
        • Async Functions
      • Background Tasks
      • Triggers
      • Middleware
      • Configuring Expressions
      • Working with Data
    • Functions
      • AI Tools
      • Database Requests
        • Query All Records
          • External Filtering Examples
        • Get Record
        • Add Record
        • Edit Record
        • Add or Edit Record
        • Patch Record
        • Delete Record
        • Bulk Operations
        • Database Transaction
        • External Database Query
        • Direct Database Query
        • Get Database Schema
      • Data Manipulation
        • Create Variable
        • Update Variable
        • Conditional
        • Switch
        • Loops
        • Math
        • Arrays
        • Objects
        • Text
      • Security
      • APIs & Lambdas
        • Realtime Functions
        • External API Request
        • Lambda Functions
      • Data Caching (Redis)
      • Custom Functions
      • Utility Functions
      • File Storage
      • Cloud Services
    • Filters
      • Manipulation
      • Math
      • Timestamp
      • Text
      • Array
      • Transform
      • Conversion
      • Comparison
      • Security
    • Data Types
      • Text
      • Expression
      • Array
      • Object
      • Integer
      • Decimal
      • Boolean
      • Timestamp
      • Null
    • Environment Variables
    • Additional Features
      • Response Caching
  • Testing and Debugging
    • Testing and Debugging Function Stacks
    • Unit Tests
    • Test Suites
  • CI/CD
  • File Storage
    • File Storage in Xano
    • Private File Storage
  • Realtime
    • Realtime in Xano
    • Channel Permissions
    • Realtime in Webflow
  • Maintenance, Monitoring, and Logging
    • Statement Explorer
    • Request History
    • Instance Dashboard
      • Memory Usage
  • Building Backend Features
    • User Authentication & User Data
      • Separating User Data
      • Restricting Access (RBAC)
      • OAuth (SSO)
    • Webhooks
    • Messaging
    • Emails
    • Custom Report Generation
    • Fuzzy Search
    • Chatbots
  • Xano Features
    • Snippets
    • Instance Settings
      • Release Track Preferences
      • Static IP (Outgoing)
      • Change Server Region
      • Direct Database Connector
      • Backup and Restore
      • Security Policy
    • Advanced Back-end Features
      • Xano Link
      • Developer API (Deprecated)
    • Metadata API
      • Master Metadata API
      • Tables and Schema
      • Content
      • Search
      • File
      • Request History
      • Workspace Import and Export
      • Token Scopes Reference
  • Xano AI
    • Building a Backend Using AI
    • Get Started Assistant
    • AI Database Assistant
    • AI Lambda Assistant
    • AI SQL Assistant
    • API Request Assistant
    • Template Engine
    • Streaming APIs
  • AI Tools
    • MCP Servers
      • Connecting Clients
      • MCP Functions
  • Xano Transform
    • Using Xano Transform
  • Xano Actions
    • What are Actions?
    • Browse Actions
  • Team Collaboration
    • Realtime Collaboration
    • Managing Team Members
    • Branching & Merging
    • Role-based Access Control (RBAC)
  • Agencies
    • Xano for Agencies
    • Agency Features
      • Agency Dashboard
      • Client Invite
      • Transfer Ownership
      • Agency Profile
      • Commission
      • Private Marketplace
  • Enterprise
    • Xano for Enterprise
    • Enterprise Features
      • Microservices
      • Tenant Center
      • Compliance Center
      • Security Policy
      • Instance Activity
      • Deployment
      • RBAC (Role-based Access Control)
      • Xano Link
  • Your Xano Account
    • Account Page
    • Billing
    • Referrals & Commissions
  • Troubleshooting & Support
    • Error Reference
    • Troubleshooting Performance
      • When a single workflow feels slow
      • When everything feels slow
      • RAM Usage
      • Function Stack Performance
    • Getting Help
      • Granting Access
      • Community Code of Conduct
      • Community Content Modification Policy
  • Special Pricing
    • Students & Education
    • Non-Profits
  • Security
    • Best Practices
Powered by GitBook
On this page
  • Step 1: Generate your Developer API Key
  • Step 2: Xano Master Service Documentation
  • Step 3: Fetch the tokenUrl for your instance
  • Step 4: Call the APIs of your Instance

Was this helpful?

Developer API (Deprecated)

Last updated 3 months ago

Was this helpful?

The Developer API is deprecated. Please see the for the newest solution.

The Xano Developer API allows you to interact with your account in an automated fashion.

The primary use case is the ability to authenticate and then retrieve Swagger/OpenAPI documentation for each of your API groups on each of your Xano instances. More functionality will be coming soon.

Since Xano supports a single tenant infrastructure on each of its premium instances, it is important to understand that different authentication is required for different aspects of this API.

Authentication starts with your Developer API Key, which allows you to authenticate your account with the master service. This master service is responsible for managing your account, subscriptions, and instances.

By listing each instance you have access to, you will then be able to re-authenticate with each individual instance to view the Developer API for that instance. Then you will have access to list workspaces and the API groups within each workspace, which then gives you access to the appropriate Swagger documentation for each API group.

Step 1: Generate your Developer API Key

This is available on the Account page. Every account has the ability to have a single Developer API Key. Once this is generated, it is no longer possible to view the key, so it is very important to write this down in a safe place, so it isn't forgotten. If it is forgotten, then you need to revoke the current one and generate a new key.

Step 2: Xano Master Service Documentation

Currently, there is only support to list your Xano instances, but more functionality will be fleshed out over the next several releases.

Authentication is handled using the Authorization HTTP header along with the Bearer token specification.

If you are viewing the Swagger documentation, then you can click the "Authorize" button and paste in your Developer API key. Then you can click on the Instances endpoint and click the "Try Out" button to execute the API endpoint.

If you are using the API directly via your front-end or the CURL command line utility, then you would need to include your Developer API key as follows.

In the CURL example below you would replace the text YOUR_DEVELOPER_API_KEY with your actual Developer API Key.

curl -X 'GET' \
  'https://app.xano.com/api:developer/instance' \
  -H 'accept: application/json' \
  -H 'Authorization: Bearer YOUR_DEVELOPER_API_KEY'

The following would be an example response to expect, if your account had access to two instances.

[
  {
    "id": 1,
    "name": "explore-instance",
    "display": "Explore Instance",
    "description": "",
    "host": "",
    "tokenUrl": "https://app.xano.com/api:developer/token/auth?token=DBWJQ2..."
  },
  {
    "id": 2,
    "name": "starter-instance",
    "display": "Starter Instance",
    "description": "",
    "host": "",
    "tokenUrl": "https://app.xano.com/api:developer/token/auth?token=6B67wcN..."
  }
]

Step 3: Fetch the tokenUrl for your instance

The tokenUrl for each instance has an authenticated token parameter to give you access to the Authorization token required to call the API for that specific instance.

In the above example, if we fetch the tokenUrl, then the following example response would be expected.

{
  "authToken": "eyJhbGciOiJBMjU2S1ciLCJlbmMiOiJ...",
  "api": "https://x8d0-doy0-xx99.n0.xano.io/api:developer",
  "swaggerspec": "https://x8d0-doy0-xx99.n0.xano.io/apispec:developer?type=json",
  "origin": "https://x8d0-doy0-xx99.n0.xano.io"
}

The authToken key will be used to authenticate to any endpoints listed within the API or swaggerspec links.

The API key is a link to the Swagger documentation for the Developer APIs for this specific instance.

The swaggerspec key is a link to the json spec for the Swagger documentation in case you want to programmatically parse the endpoints available within the documentation.

The origin key is useful for knowing the desired http origin of any requests sent to the instance. This is normally Xano URL, but can change if a custom domain is enabled.

Step 4: Call the APIs of your Instance

Now that we have the authToken from Step 3, we can call the endpoints available within the API link above.

Any endpoints within this instance that require authentication, must use this authToken and not your API Developer Key. The API Developer Key is only intended for the Xano master service.

curl -X 'GET' \
  'https://x8d0-doy0-xx99.n0.xano.io/api:developer/workspace' \
  -H 'accept: application/json' \
  -H 'Authorization: Bearer eyJhbGciOiJBMjU2S1ciLCJlbmMiOiJ...'

Below is an example response to the workspace endpoint listed above.

[
  {
    "id": 2,
    "name": "Book Marketplace",
    "description": "This is an example workspace.",
    "apigroups": [
      {
        "id": 4,
        "name": "Public API",
        "description": "",
        "api": "https://x8d0-doy0-xx99.n0.xano.io/api:Wk_siXX",
        "swaggerspec": "https://x8d0-doy0-xx99.n0.xano.io/apispec:Wk_siXX"
      },
      {
        "id": 5,
        "name": "Private API",
        "description": "",
        "api": "https://xb17-541e-40b9.dev.xano.io/api:YkBUXX",
        "swaggerspec": "https://xb17-541e-40b9.dev.xano.io/apispec:YkBUXX"
      }
    ]
  }
]

From this response, you can see there is one workspace with two API Groups. Each API Group has its own api and swaggerspec key. The difference here is that these APIs are the ones built by you in your own instance. This also means that these will require their own Authentication.

Now that you have your API Key, you can start authenticating against the API endpoints for the Xano master service. The API documentation is detailed at .

https://app.xano.com/api:developer
Metadata API (beta)
Generate a Developer API key from the Account page.