Custom software, like the apps made in Glide, is most useful when it is populated with rich, specific company data. This is easy to do with native integrations and APIs, but sometimes you have data in CSV form that you just have to get into your Glide apps. You can use these CSV uploads to get critical data from siloed software and databases and into a wide variety of custom apps.
Use these techniques to:
Add contacts to a CRM.
Add expenses to an expense log.
Add properties to a real estate manager.
Add rosters to an LMS.
Glide doesn’t natively support direct CSV uploads by end-users, but these two workarounds are easy and quick. Follow the steps below to import CSV data into your Glide app, with clear instructions for each step.
Overview:
Method 1: Looping Workflow - Import each row one-by-one using Glide’s internal actions (best for small files under ~100 rows).
Method 2: Glide API + “Stashing” - Import all rows into Glide Big Tables in bulk via Glide’s API v2 (for large files 1,000+ rows).
Each tutorial covers setting up an import screen, validating/parsing the CSV, and running the import. You prefer learning from video, my detailed YouTube tutorial is above.
Method 1: Looping workflow (use for < 100 records)
This method uses a Glide manual workflow to add records one at a time from the CSV. It’s straightforward to set up entirely in Glide. Keep in mind it’s best for smaller imports (around 100 rows max) to avoid hitting Glide’s operation limits.
1. Set up an import screen
Create a new screen (or tab) in your app for CSV importing. Add a new Glide Table (e.g. “Import” or “Staging”) with columns to hold the CSV data temporarily. Include a File Picker component on the screen so the user can upload their CSV file. Store this in a user-specific file column in the Import table. Also add an “Import” button that will trigger the workflow to process the file. Using a user-specific column for the file ensures each user’s upload won’t conflict with others.
2. Validate CSV headers
After the user uploads a file, verify that the CSV’s first row (the header) matches your expected columns. For example, if your app expects columns Name, Email, Phone, make sure the CSV has those headers in the first row. You can do this by storing the first line of the file, using a split text or a small JS code column, and comparing it to a template string of the correct headers.
Tip: Provide a sample template CSV to your users with the correct column names – this prevents header mismatches and import errors.
3. Parse the CSV rows
Next, convert the CSV file content into individual rows of data that Glide can work with. Use Glide’s computed columns or a single JavaScript column to split the CSV text into an array of rows. For example, you might split the file text on the newline character to get a list of all rows. Each row can then be further split by commas to isolate each field. The goal is to have each CSV row’s values accessible in your Import table, either as an array or via helper sub-columns. This essentially transforms the raw CSV text into structured data that Glide can loop through.
4. Run a looping import workflow
Configure the “Import” button to run a custom action or workflow that loops through each parsed row and adds it to the target data table. Glide’s Workflow builder allows you to iterate over a list of items (in this case, the list of CSV rows) and perform actions for each. In the workflow, use an Add Row step to take each CSV row’s values and insert a new row into your table. The loop will repeat until all rows from the CSV are added.
Note: Because this method adds rows one-by-one, it will use one update per row – avoid CSVs larger than ~100 rows to stay within Glide’s limits and to prevent slow processing.
5. Test and confirm
Before using it with real data, test the entire flow with a small CSV (e.g. 5–10 rows) to ensure everything is mapped correctly and the workflow runs smoothly. Once confirmed, your users can upload their CSV and tap Import, and the app will sequentially add each record. Provide feedback on the screen, such as a success message or a count of rows imported, so the user knows when the import is complete.
Method 2: Glide API + stashing (for large imports 1,000+ records)
This method takes advantage of Glide’s API v2 with a feature called stashing to upload many rows in bulk. It’s more advanced but can handle very large CSV files efficiently. Instead of looping through each row in the app, you will prepare all the data in a JSON format and send it to Glide in a few calls. Glide will then add hundreds or thousands of rows almost instantly on the backend, using only minimal update operations. For example, ~2,000 records can be added with ~20 updates via stashing, instead of 2,000 updates one-by-one.
1. Set up import interface & API access
The on-screen setup is similar to Method 1. You still use a File Picker for the user to upload the CSV and an Import button to initiate the process. However, instead of a looping workflow, this button will trigger a Call API action. Obtain your Glide app’s API endpoint and an API key or auth token (from your app settings or Glide documentation) so you can authenticate requests.
In Glide, create a manual workflow with a Manual Trigger that will be activated by the Import button, and add a Call API step in that workflow. This is how we will send the data to Glide’s API in bulk. Make sure you’ve enabled any required permissions or set up the API key in the headers of the call.
2. Validate the CSV structure
Just like in Method 1, verify the uploaded CSV’s format before importing. Check that the header row matches your Glide table’s fields. This step is crucial because you will be mapping CSV columns to specific table fields in the JSON payload. Using the same template CSV approach here can save headaches. It ensures the CSV columns are exactly what your import logic expects.
3. Convert CSV to JSON payload
Parse the CSV file into a JSON structure that the Glide API can accept. You can do this within Glide using a JavaScript column or by sending the file to an external service, but often it’s easiest to handle it in-app for simplicity. For example, use a JS code column to fetch the CSV file’s text and convert it into a JSON array of objects.
Each object in the array will represent one row of data, with keys as your table’s column IDs and values as the row’s data. Glide’s API requires using internal column IDs, not the human-readable column names. You can find these IDs in the Glide Data Editor or API docs, and you must map your CSV headers to these IDs in the JSON. The end result should be a JSON payload containing a list of “add row” instructions, often called mutations, for all the records in the CSV.
4. Call the Glide API to add rows
With the JSON payload ready, use the Call API action to send it to Glide’s API endpoint for adding multiple rows. In your workflow, the Call API step should be configured with the endpoint (including your App ID) and the JSON body you prepared, along with the required authorization header. When you trigger this action, Glide’s backend will stash the incoming data and add all the rows to your table in one go or in a few quick batches. Thanks to stashing, hundreds of rows can be inserted nearly instantaneously and with very few update counts used.
Tip: If your CSV is extremely large (thousands of rows), you may choose to split the data into chunks (for example, 500 rows per API call) to ensure the request isn’t too big. You can loop the Call API action multiple times, or have your JSON payload segmented, to handle very large imports safely. In most cases, though, a single well-crafted payload will handle a typical large CSV.
5. Confirm the bulk import
After the API call(s) complete, verify that the new records have appeared in your Glide table. Because this method bypasses the UI loop and uses the backend API, the import should finish almost immediately even for thousands of rows. It’s a good practice to show a confirmation to the user, such as “Import complete! (X rows added)”. You should also handle any errors (if the API returns an error, e.g. due to a formatting issue) by informing the user to check their CSV formatting. Finally, test this process with a small batch first to ensure your JSON mapping is correct and everything works as expected before attempting a very large import.
Use data from anywhere in Glide
Both methods enable easy CSV imports in Glide. Choose Method 1 for simplicity with smaller datasets, and Method 2 for efficiency with large datasets. By building a user-friendly import screen, validating the CSV format, and either looping through rows or using Glide’s API, you can let your app users upload bulk data quickly and smoothly.
Whether you're building for your company or you're an Expert creating business software for clients, this is a great technique to be aware of. It's all about using data more effectively and saving you and your users time, which makes for a much more pleasant user experience.
