{"id":22320,"date":"2021-04-19T15:17:23","date_gmt":"2021-04-19T15:17:23","guid":{"rendered":"http:\/\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary"},"modified":"2023-09-19T14:25:27","modified_gmt":"2023-09-19T21:25:27","slug":"creating_an_api_with_python_flask_to_upload_files_to_cloudinary","status":"publish","type":"post","link":"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary","title":{"rendered":"Creating an API With Python Flask to Upload Files to Cloudinary"},"content":{"rendered":"

Code<\/a><\/p>\n

Cloudinary offers SDKs for many programming languages and frameworks. Even though it also offers an Upload API endpoint for both back-end and front-end code, most developers find the SDKs very helpful. If you\u2019re working with a powerful back-end framework like Python Flask, you\u2019ll be happy to hear that a Python SDK is now available.
\nThis tutorial walks you through the process of building an API to upload images to Cloudinary. You can also upload other file types, including video and even nonmedia files, with the API.<\/p>\n

Understanding the Difference Between Back End and Front End<\/h2>\n

Generally, code that runs on the server is back end<\/strong>, and code that runs on the browser is front end<\/strong>. However, since server code can render HTML, CSS, and JavaScript, which all run on the browser, confusion sometimes results.\nIn the context of the Cloudinary SDKs, the back-end ones can read secret credentials, which should not be shared in the front end. In other words, you must never expose the back-end environment variables in the front end because front-end SDKs cannot hide credentials that are meant to be kept secret. As a solution, you can upload browser code with Cloudinary\u2019s unsigned presets<\/strong><\/a> without revealing secret credentials. A better way would be to build a back-end API for secure uploads, keeping your API_SECRET<\/code> credential hidden. Read on to see how to do that with Cloudinary\u2019s Python SDK and Python Flask or Python Django.<\/p>\n

Coding a Flask API to Upload to Cloudinary<\/h2>\n

The Flask framework makes it easy to define routes and their functionalities. To get started, first create a route named \/upload<\/code>, which accepts a POST<\/code> that contains multipart\/form-data<\/a>. You then package up the image file input into a FormData<\/code> object in a submit handler and POST<\/code> it to your own Flask API to call Cloudinary\u2019s Upload API, which is configured with your full set of Cloudinary credentials.<\/p>\n

Flask\u2019s request<\/code> option enables you to get data from the client. When submitting files, such as uploading images, you can call upon request<\/code> to access them.<\/p>\n

from<\/span> flask import<\/span> Flask,render_template, request\nif<\/span> request.method == 'POST'<\/span>:\n    file_to_upload = request.files['file'<\/span>]\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n
\nHowever, if you’re looking to simplify the process of building RESTful web services with Flask, you can utilize the flask_restful <\/strong>module. By creating a new class that inherits from Resource<\/strong>, you can define a post() <\/strong>method that accepts the file as a parameter. The werkzeug.datastructures.FileStorage<\/strong> class can be used to get the file object, which can then be saved to a desired location.\n<\/p>\n
\nHere’s an example of how you can integrate this approach:\n<\/p>\n
from flask import Flask, request from flask_restful import Resource, Api from werkzeug.datastructures import FileStorage app = Flask(__name__) api = Api(app) class UploadFile(Resource): def post(self): file = request.files['file'] file.save('\/uploads\/' + file.filename) return 'File uploaded successfully!' api.add_resource(UploadFile, '\/upload')\n<\/pre>\n
\nThis code creates a new Flask project and an API endpoint that allows users to upload files. The post()<\/strong> method of the UploadFile <\/strong>class accepts the file as a parameter and saves it to the \/uploads<\/strong> directory. The return statement provides a success message. To test this code, tools like Postman can be used to send a POST request to the \/upload<\/strong> endpoint.\n<\/p>\n
The data retrieved from request.files['file']<\/code> is an instance of werkzeug.FileStorage<\/code>. The object can be handed off to the Python SDK\u2019s Upload function. Flask then wraps Werkzeug<\/a>, which handles the details of the Web Server Gateway Interface (WSGI).<\/p>\n
if file_to_upload:\n    upload_result = cloudinary.uploader.upload(file_to_upload)\n    app.logger.info(upload_result)\n<\/code><\/span><\/pre>\n
For uploads to Cloudinary, the default resource_type<\/code> is image<\/code>. To expand or create a new Flask API, add resource_type: 'video'<\/code> or resource_type: 'raw'<\/code> for video or raw files, respectively.  Raw<\/a> refers to nonmedia file formats, including text and JSON.<\/p>\n
Finally, upload_result<\/code> is an object that contains the upload response. To complete the actions of your upload<\/code> API, return that response to the client, like this:<\/p>\n
from<\/span> flask import<\/span> jsonify\nreturn<\/span> jsonify(upload_result)\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n
Below is the complete code of your upload<\/code> API.<\/p>\n
@app.route(\"\/upload\"<\/span>, methods=['POST'<\/span>])\ndef upload_file():\n  app.logger.info('in upload route'<\/span>)\n\n  cloudinary.config(cloud_name = os.getenv('CLOUD_NAME'<\/span>), api_key=os.getenv('API_KEY'<\/span>), \n    api_secret=os.getenv('API_SECRET'<\/span>))\n  upload_result = None\n  if<\/span> request.method == 'POST'<\/span>:\n    file_to_upload = request.files['file'<\/span>]\n    app.logger.info('%s file_to_upload'<\/span>, file_to_upload)\n    if<\/span> file_to_upload:\n      upload_result = cloudinary.uploader.upload(file_to_upload)\n      app.logger.info(upload_result)\n      return<\/span> jsonify(upload_result)\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n
Setting Up the Flask App<\/h2>\n
Next, follow the steps below to build the app.<\/p>\n
Set Up the Virtual Environment<\/h3>\n
The command below establishes your virtual environment. This is an important step for encapsulating the libraries you\u2019ll be using in this app.<\/p>\n
python3 -m venv env\nsource env\/bin\/activate\n<\/code><\/span><\/pre>\n
To  deactivate the environment, type:<\/p>\n
deactivate\nsource env\/bin\/activate\n<\/code><\/span><\/pre>\n
Install Flask<\/h3>\n
Install Flask with this command:<\/p>\n
python3 -m pip install Flask==1.1.1\n<\/code><\/span><\/pre>\n
Add a requirements.txt<\/code> File<\/h3>\n
Create a requirements.txt<\/code> file to keep track of all the versioned libraries you need for the app and to facilitate future deployment.<\/p>\n
python3<\/span> -m<\/span> pip<\/span> freeze<\/span> > requirements<\/span>.txt<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n
Upgrade the Python Package Installer<\/h3>\n
If necessary, upgrade the Python package installer, called PIP, with the command below. The command might vary, depending on your local Python installation. As shown below, the freeze<\/code> command writes the library and version to the requirements.txt<\/code> file.<\/p>\n
usr\/local\/opt\/python@3.9\/bin\/python3.9 -m pip install --upgrade pip\npython3 -m pip freeze > requirements.txt\n<\/code><\/span><\/pre>\n
Install Cloudinary<\/h3>\n
Next, install Cloudinary to gain access to its Upload API for the Python SDK.<\/p>\n
 python3<\/span> -m<\/span> pip<\/span> install<\/span> cloudinary<\/span>\n python3<\/span> -m<\/span> pip<\/span> freeze<\/span> > requirements<\/span>.txt<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n
Add CORS support<\/h3>\n
If you want to access your upload<\/code> API from a client served from a different host, add Cross Origin Resource Sharing (CORS) support:<\/p>\n
python3<\/span> -m<\/span> pip<\/span> install<\/span> flask-cors<\/span>\npython3<\/span> -m<\/span> pip<\/span> freeze<\/span> > requirements<\/span>.txt<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n
Now you can add code to configure CORS for all the APIs and, specifically, the upload<\/code> API. The code below demonstrates both options.<\/p>\n
from flask_cors import CORS, cross_origin\napp = Flask(__name__)\n# After creating the Flask app, you can make all APIs allow cross-origin access.<\/span>\nCORS(app)\n# or a specific API<\/span>\n@app.route(\"\/upload\"<\/span>, methods=['POST'<\/span>])\n@cross_origin()\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n
Work With Environment Variables<\/h3>\n
You can easily load environment variables with Python. Conveniently, the python-dotenv<\/code> library is modeled on the Node.js dotenv<\/code> package. You need three Cloudinary environment variables, i.e., CLOUD_NAME<\/code>, API_KEY<\/code>, and API_SECRET<\/code>, for your code, but don\u2019t share API_SECRET<\/code>.  You can export those variables to the local environment. When you deploy to Heroku, you can add them to make them available to the app when it runs in a Heroku container.<\/p>\n
from<\/span> dotenv import<\/span> load_dotenv\nload_dotenv()\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n
In your upload<\/code> API, you read in the environment variables with the cloudinary.config()<\/code> function. You then access those variables with the os.getenv()<\/code> function in the dotenv<\/code> library.<\/p>\n
cloudinary.config(cloud_name = os.getenv('CLOUD_NAME'<\/span>), api_key=os.getenv('API_KEY'<\/span>), \n    api_secret=os.getenv('API_SECRET'<\/span>))\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n
When working locally, you can create a gitignore\u2019d .env<\/code> file that contains your Cloudinary credentials for local testing. The values for those credentials are displayed in your Cloudinary console.<\/p>\n
CLOUD_NAME=CLOUD_NAME\nAPI_KEY=API_KEY\nAPI_SECRET=API_SECRET\n<\/code><\/span><\/pre>\n
Next, install the python-dotenv<\/code> library:<\/p>\n
python3<\/span> -m<\/span> pip<\/span> install<\/span> python-dotenv<\/span>\npython3<\/span> -m<\/span> pip<\/span> freeze<\/span> > requirements<\/span>.txt<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n
Testing the API Locally<\/h2>\n
You\u2019re now ready to test the app locally. You can do end-to-end testing with Postman and a local form that points at a server running on localhost<\/code>.<\/p>\n
Create your app with an upload function by downloading, cloning, or copying from this GitHub repository<\/a>. Add your credentials to a .env<\/code> file and then start your server on localhost<\/code>.<\/p>\n
python3<\/span> app<\/span>.py<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n
The above command opens a server at http:\/\/127.0.0.1:5000\/<\/code>. Note that the default port is 5000.<\/p>\n
Test With Postman<\/h3>\n
In Postman, do the following:<\/p>\n
    \n
  1. Set the method to POST<\/code>.<\/li>\n
  2. Set the body type to form-data<\/code>.<\/li>\n
  3. Establish Key\/Value pairs for input. Set the value for the Key to file<\/code>. Mouse over the Key<\/strong> field and choose Text<\/strong> or File<\/strong> from the drop-down menu. Under File<\/strong> is a Select Files<\/strong> button; click it to select a file from your local drive.<\/li>\n
  4. Click Send<\/strong> to process the request.<\/li>\n<\/ol>\n
    The Cloudinary Upload API response is displayed at the bottom of the page<\/p>\n
    \"Localhost<\/p>\n
    Test With a Local Form<\/h3>\n
    Follow these steps:<\/p>\n
      \n
    1. \n
      Open the index.html<\/code> file with a local HTTP server. Choose a local file and click Upload<\/strong>.<\/p>\n<\/li>\n
    2. \n
      Run the JavaScript code below. The fetch<\/code> command calls the server that runs on  localhost<\/code>.<\/p>\n
      fetch(\"http:\/\/127.0.0.1:5000\/upload\"<\/span>, options)\n  .then((response<\/span>) =><\/span> {\n    return<\/span> response.json();\n  })\n  .then((data<\/span>) =><\/span> {\n    console<\/span>.log(data);\n  })\n  .catch((error<\/span>) =><\/span> {\n    console<\/span>.log(error);\n  });\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n
      If the process is successful, the Cloudinary Upload API response is displayed in the console.  Don\u2019t forget to set event.preventDefault();<\/code> for the submit handler. Otherwise, you\u2019ll get a page refresh and won\u2019t see your log.<\/p>\n<\/li>\n
    3. \n
      Post a file in a submit handler by creating a FormData<\/code> object and appending the file, as shown in the code below.<\/p>\n
      const<\/span> formData = new<\/span> FormData();\nformData.append(\"file\"<\/span>, fileInput.files[0<\/span>]);\nconst<\/span> options = {\n  method<\/span>: \"POST\"<\/span>,\n  body<\/span>: formData,\n};\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n<\/li>\n<\/ol>\n
      The above code packages up the file you select in your form input as if you had submitted a multipart form. A multipart form is important for submitting files because each input is sent as a block of data, separated by boundaries.\nThe result is then displayed in your console, like this:<\/p>\n
      \"local<\/p>\n
      Deploying the Flask App to Heroku<\/h2>\n
      Heroku is a platform as a service (PaaS) for serving prototypes or production-ready apps. Host the API you just built on Heroku by doing the following:<\/p>\n
        \n
      1. \n
        Create a free account on Heroku.<\/p>\n<\/li>\n
      2. \n
        Install Gunicorn<\/a>, short for Green Unicorn, a Python WSGI HTTP server for hosting apps.<\/p>\n
        python3 -m pip install gunicorn==20.0.4\npython3 -m pip freeze > requirements.txt\n<\/code><\/span><\/pre>\n<\/li>\n
      3. \n
        Create a file called Prodfile<\/code> with instructions for Heroku to start your app with Gunicorn:<\/p>\n
        web<\/span>: gunicorn<\/span> app<\/span>:app<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n<\/li>\n
      4. \n
        Create a file called runtime.txt<\/code> that contains the Python version you want to use:<\/p>\n
        python-3<\/span>.9<\/span>.1<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n<\/li>\n
      5. \n
        Deploy with Git:<\/p>\n
        git init\ngit add .\ngit commit -m\"my first commit\"<\/span>\n# Create a new Heroku app<\/span>\nheroku create\n# You will get a URL where the app will be hosted<\/span>\ngit remote -v\n# will confirm that you have set up a remote to push to Heroku<\/span>\n\n# If you have an existing Heroku app that you created in the Heroku GUI<\/span>\n# you can add it with this command instead of creating a new one<\/span>\nheroku git:remote -a thawing-inlet-61413<\/span>\n\n# To deploy, you can now just push to Heroku<\/span>\ngit push heroku master\n\n# Open your server (it's nice to have a GET method so you can verify like this)<\/span>\nheroku open\n\n# To log in to Heroku from the command line, type:<\/span>\nheroku login\n# You\u2019ll then be prompted to open the webpage to log in<\/span>\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n<\/li>\n<\/ol>\n
        You can build the new Heroku app with the CLI. However, as noted above, if you built it on the heroku.com dashboard, you can just add the link Heroku created for you to a git:remote<\/code> command.<\/p>\n
        Testing the API Deployed on Heroku<\/h2>\n
        If you have a GET<\/code> method API like the \u201cHello World!\u201d in the app.py<\/code> example, you can open the Heroku app in the browser.<\/p>\n
        For end-to-end testing, you can POST<\/code> to the Heroku server link from Postman. The result is similar to that for local testing.<\/p>\n
        \"Remote<\/p>\n
        Alternatively, modify the index.html<\/code> file to post to your Heroku server. Just add your Heroku server link to the fetch<\/code> command, like this:<\/p>\n
        fetch(\"https:\/\/xxxx.herokuapp.com\"<\/span>, options)\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n
        Securing the App<\/h2>\n
        You might have noticed that the Heroku deployment link has been erased from the images above. That\u2019s for security. Deploying this app to Heroku enables you to upload data to Cloudinary. If the link is not secured for use on an authenticated webpage only, anyone can upload to your Cloudinary cloud. Even though you are hiding your environment variables, you\u2019d have created a public method to change data on your cloud.<\/p>\n
        This tutorial does not cover how to set up authentication. Many options are available for authentication of API routes. You might want to look into Auth0, Google, or GitHub.  Alternatively, build your own process based on your user database for this type of authentication.<\/p>\n
        Moving On<\/h2>\n
        Once you get this API running, you can build other media APIs with the Cloudinary Python SDK by following the same pattern. Have fun!<\/p>\n<\/div>","protected":false},"excerpt":{"rendered":"","protected":false},"author":41,"featured_media":22321,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"_cloudinary_featured_overwrite":false,"footnotes":""},"categories":[1],"tags":[263],"class_list":["post-22320","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-uncategorized","tag-sdk"],"acf":[],"yoast_head":"\nCreating an API With Python Flask to Upload Files to Cloudinary<\/title>\n<meta name=\"description\" content=\"Learn how to build an API with Python Flask and Cloudinary's Python SDK to upload files of any format to Cloudinary.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Creating an API With Python Flask to Upload Files to Cloudinary\" \/>\n<meta property=\"og:description\" content=\"Learn how to build an API with Python Flask and Cloudinary's Python SDK to upload files of any format to Cloudinary.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary\" \/>\n<meta property=\"og:site_name\" content=\"Cloudinary Blog\" \/>\n<meta property=\"article:published_time\" content=\"2021-04-19T15:17:23+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-09-19T21:25:27+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/res.cloudinary.com\/cloudinary-marketing\/images\/v1649718612\/Web_Assets\/blog\/Python_Flask_API_223210efa9\/Python_Flask_API_223210efa9-png?_i=AA\" \/>\n\t<meta property=\"og:image:width\" content=\"1540\" \/>\n\t<meta property=\"og:image:height\" content=\"847\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"NewsArticle\",\"@id\":\"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary#article\",\"isPartOf\":{\"@id\":\"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary\"},\"author\":{\"name\":\"\",\"@id\":\"\"},\"headline\":\"Creating an API With Python Flask to Upload Files to Cloudinary\",\"datePublished\":\"2021-04-19T15:17:23+00:00\",\"dateModified\":\"2023-09-19T21:25:27+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary\"},\"wordCount\":11,\"publisher\":{\"@id\":\"https:\/\/cloudinary.com\/blog\/#organization\"},\"image\":{\"@id\":\"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary#primaryimage\"},\"thumbnailUrl\":\"https:\/\/res.cloudinary.com\/cloudinary-marketing\/images\/f_auto,q_auto\/v1649718612\/Web_Assets\/blog\/Python_Flask_API_223210efa9\/Python_Flask_API_223210efa9.png?_i=AA\",\"keywords\":[\"SDK\"],\"inLanguage\":\"en-US\",\"copyrightYear\":\"2021\",\"copyrightHolder\":{\"@id\":\"https:\/\/cloudinary.com\/#organization\"}},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary\",\"url\":\"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary\",\"name\":\"Creating an API With Python Flask to Upload Files to Cloudinary\",\"isPartOf\":{\"@id\":\"https:\/\/cloudinary.com\/blog\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary#primaryimage\"},\"image\":{\"@id\":\"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary#primaryimage\"},\"thumbnailUrl\":\"https:\/\/res.cloudinary.com\/cloudinary-marketing\/images\/f_auto,q_auto\/v1649718612\/Web_Assets\/blog\/Python_Flask_API_223210efa9\/Python_Flask_API_223210efa9.png?_i=AA\",\"datePublished\":\"2021-04-19T15:17:23+00:00\",\"dateModified\":\"2023-09-19T21:25:27+00:00\",\"description\":\"Learn how to build an API with Python Flask and Cloudinary's Python SDK to upload files of any format to Cloudinary.\",\"breadcrumb\":{\"@id\":\"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary#primaryimage\",\"url\":\"https:\/\/res.cloudinary.com\/cloudinary-marketing\/images\/f_auto,q_auto\/v1649718612\/Web_Assets\/blog\/Python_Flask_API_223210efa9\/Python_Flask_API_223210efa9.png?_i=AA\",\"contentUrl\":\"https:\/\/res.cloudinary.com\/cloudinary-marketing\/images\/f_auto,q_auto\/v1649718612\/Web_Assets\/blog\/Python_Flask_API_223210efa9\/Python_Flask_API_223210efa9.png?_i=AA\",\"width\":1540,\"height\":847},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/cloudinary.com\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Creating an API With Python Flask to Upload Files to Cloudinary\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/cloudinary.com\/blog\/#website\",\"url\":\"https:\/\/cloudinary.com\/blog\/\",\"name\":\"Cloudinary Blog\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/cloudinary.com\/blog\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/cloudinary.com\/blog\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/cloudinary.com\/blog\/#organization\",\"name\":\"Cloudinary Blog\",\"url\":\"https:\/\/cloudinary.com\/blog\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/cloudinary.com\/blog\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/res.cloudinary.com\/cloudinary-marketing\/images\/f_auto,q_auto\/v1649718331\/Web_Assets\/blog\/cloudinary_logo_for_white_bg_1937437aa7_19374666c7_193742f877\/cloudinary_logo_for_white_bg_1937437aa7_19374666c7_193742f877.png?_i=AA\",\"contentUrl\":\"https:\/\/res.cloudinary.com\/cloudinary-marketing\/images\/f_auto,q_auto\/v1649718331\/Web_Assets\/blog\/cloudinary_logo_for_white_bg_1937437aa7_19374666c7_193742f877\/cloudinary_logo_for_white_bg_1937437aa7_19374666c7_193742f877.png?_i=AA\",\"width\":312,\"height\":60,\"caption\":\"Cloudinary Blog\"},\"image\":{\"@id\":\"https:\/\/cloudinary.com\/blog\/#\/schema\/logo\/image\/\"}},{\"@type\":\"Person\",\"@id\":\"\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Creating an API With Python Flask to Upload Files to Cloudinary","description":"Learn how to build an API with Python Flask and Cloudinary's Python SDK to upload files of any format to Cloudinary.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary","og_locale":"en_US","og_type":"article","og_title":"Creating an API With Python Flask to Upload Files to Cloudinary","og_description":"Learn how to build an API with Python Flask and Cloudinary's Python SDK to upload files of any format to Cloudinary.","og_url":"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary","og_site_name":"Cloudinary Blog","article_published_time":"2021-04-19T15:17:23+00:00","article_modified_time":"2023-09-19T21:25:27+00:00","og_image":[{"width":1540,"height":847,"url":"https:\/\/res.cloudinary.com\/cloudinary-marketing\/images\/v1649718612\/Web_Assets\/blog\/Python_Flask_API_223210efa9\/Python_Flask_API_223210efa9-png?_i=AA","type":"image\/png"}],"twitter_card":"summary_large_image","schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"NewsArticle","@id":"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary#article","isPartOf":{"@id":"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary"},"author":{"name":"","@id":""},"headline":"Creating an API With Python Flask to Upload Files to Cloudinary","datePublished":"2021-04-19T15:17:23+00:00","dateModified":"2023-09-19T21:25:27+00:00","mainEntityOfPage":{"@id":"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary"},"wordCount":11,"publisher":{"@id":"https:\/\/cloudinary.com\/blog\/#organization"},"image":{"@id":"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary#primaryimage"},"thumbnailUrl":"https:\/\/res.cloudinary.com\/cloudinary-marketing\/images\/f_auto,q_auto\/v1649718612\/Web_Assets\/blog\/Python_Flask_API_223210efa9\/Python_Flask_API_223210efa9.png?_i=AA","keywords":["SDK"],"inLanguage":"en-US","copyrightYear":"2021","copyrightHolder":{"@id":"https:\/\/cloudinary.com\/#organization"}},{"@type":"WebPage","@id":"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary","url":"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary","name":"Creating an API With Python Flask to Upload Files to Cloudinary","isPartOf":{"@id":"https:\/\/cloudinary.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary#primaryimage"},"image":{"@id":"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary#primaryimage"},"thumbnailUrl":"https:\/\/res.cloudinary.com\/cloudinary-marketing\/images\/f_auto,q_auto\/v1649718612\/Web_Assets\/blog\/Python_Flask_API_223210efa9\/Python_Flask_API_223210efa9.png?_i=AA","datePublished":"2021-04-19T15:17:23+00:00","dateModified":"2023-09-19T21:25:27+00:00","description":"Learn how to build an API with Python Flask and Cloudinary's Python SDK to upload files of any format to Cloudinary.","breadcrumb":{"@id":"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary#primaryimage","url":"https:\/\/res.cloudinary.com\/cloudinary-marketing\/images\/f_auto,q_auto\/v1649718612\/Web_Assets\/blog\/Python_Flask_API_223210efa9\/Python_Flask_API_223210efa9.png?_i=AA","contentUrl":"https:\/\/res.cloudinary.com\/cloudinary-marketing\/images\/f_auto,q_auto\/v1649718612\/Web_Assets\/blog\/Python_Flask_API_223210efa9\/Python_Flask_API_223210efa9.png?_i=AA","width":1540,"height":847},{"@type":"BreadcrumbList","@id":"https:\/\/cloudinary.com\/blog\/creating_an_api_with_python_flask_to_upload_files_to_cloudinary#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/cloudinary.com\/blog\/"},{"@type":"ListItem","position":2,"name":"Creating an API With Python Flask to Upload Files to Cloudinary"}]},{"@type":"WebSite","@id":"https:\/\/cloudinary.com\/blog\/#website","url":"https:\/\/cloudinary.com\/blog\/","name":"Cloudinary Blog","description":"","publisher":{"@id":"https:\/\/cloudinary.com\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/cloudinary.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/cloudinary.com\/blog\/#organization","name":"Cloudinary Blog","url":"https:\/\/cloudinary.com\/blog\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/cloudinary.com\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/res.cloudinary.com\/cloudinary-marketing\/images\/f_auto,q_auto\/v1649718331\/Web_Assets\/blog\/cloudinary_logo_for_white_bg_1937437aa7_19374666c7_193742f877\/cloudinary_logo_for_white_bg_1937437aa7_19374666c7_193742f877.png?_i=AA","contentUrl":"https:\/\/res.cloudinary.com\/cloudinary-marketing\/images\/f_auto,q_auto\/v1649718331\/Web_Assets\/blog\/cloudinary_logo_for_white_bg_1937437aa7_19374666c7_193742f877\/cloudinary_logo_for_white_bg_1937437aa7_19374666c7_193742f877.png?_i=AA","width":312,"height":60,"caption":"Cloudinary Blog"},"image":{"@id":"https:\/\/cloudinary.com\/blog\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":""}]}},"jetpack_featured_media_url":"https:\/\/res.cloudinary.com\/cloudinary-marketing\/images\/f_auto,q_auto\/v1649718612\/Web_Assets\/blog\/Python_Flask_API_223210efa9\/Python_Flask_API_223210efa9.png?_i=AA","_links":{"self":[{"href":"https:\/\/cloudinary.com\/blog\/wp-json\/wp\/v2\/posts\/22320","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/cloudinary.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/cloudinary.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/cloudinary.com\/blog\/wp-json\/wp\/v2\/users\/41"}],"replies":[{"embeddable":true,"href":"https:\/\/cloudinary.com\/blog\/wp-json\/wp\/v2\/comments?post=22320"}],"version-history":[{"count":2,"href":"https:\/\/cloudinary.com\/blog\/wp-json\/wp\/v2\/posts\/22320\/revisions"}],"predecessor-version":[{"id":31268,"href":"https:\/\/cloudinary.com\/blog\/wp-json\/wp\/v2\/posts\/22320\/revisions\/31268"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/cloudinary.com\/blog\/wp-json\/wp\/v2\/media\/22321"}],"wp:attachment":[{"href":"https:\/\/cloudinary.com\/blog\/wp-json\/wp\/v2\/media?parent=22320"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/cloudinary.com\/blog\/wp-json\/wp\/v2\/categories?post=22320"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/cloudinary.com\/blog\/wp-json\/wp\/v2\/tags?post=22320"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
        Loading Environment Variables on Heroku<\/h3>\n
        To load environment variables on Heroku, open the dashboard and navigate to your new server instance. Click the Settings<\/strong> tab and scroll down to the Config Vars<\/strong> section. Click Reveal Config Vars<\/strong>, where you can enter Key\/Value pairs. This is where you load your Cloudinary environment variables: CLOUD_NAME<\/code>, API_KEY<\/code>, and API_SECRET<\/code>.<\/p>\n
        \"Heroku<\/p>\n
        For more options for setting up prod<\/code> and dev<\/code> instances, see the Heroku documentation<\/a>.<\/p>\n