rest_api_IQP_estimator.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Qiskit Runtime REST API query & job submission [Estimator Primitive]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (Optional) Get temporary Access token from Auth API via API Token. \n",
    "\n",
    "This is especially useful if you would like control over tokens, such as token invalidation. Alternatively, you can work directly with your IBM Quantum Platform API token.\n",
    "\n",
    "More details can be found in [\"Setup an IBM Quantum Channel\" Guide](https://docs.quantum.ibm.com/guides/setup-channel#set-up-to-use-ibm-quantum-platform-with-rest-api) in the IBM Quantum Documentation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "with open('token') as file:\n",
    "    token=file.read()\n",
    "\n",
    "url = 'https://auth.quantum-computing.ibm.com/api/users/loginWithToken'\n",
    "input={'apiToken': token}\n",
    "auth_response = requests.post(url, json=input)\n",
    "auth_id=auth_response.json()['id']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GET available backends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ibm_brisbane', 'ibm_kyiv', 'ibm_kyoto', 'ibm_cusco', 'ibm_nazca'] ...\n"
     ]
    }
   ],
   "source": [
    "url_backends = 'https://api.quantum-computing.ibm.com/runtime/backends'\n",
    "headers = {'Content-Type': 'application/json',\n",
    "            'x-access-token':auth_id}\n",
    "\n",
    "backends_response = requests.get(url_backends, headers=headers)\n",
    "\n",
    "print(backends_response.json()['devices'][:5],\"...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run a job"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### set up qasm circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "qasm_string='''\n",
    "OPENQASM 3;\n",
    "include \"stdgates.inc\";\n",
    "qreg q[2];\n",
    "creg c[2];\n",
    "x q[0];\n",
    "cx q[0], q[1];\n",
    "c[0] = measure q[0]; \n",
    "c[1] = measure q[1];\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.circuit.random import random_circuit\n",
    "from qiskit import QuantumCircuit, qasm2, qasm3\n",
    " \n",
    "random_circ = random_circuit(5, depth=3, seed=42).decompose(reps=3)\n",
    "qasm_string = qasm3.dumps(random_circ)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qasm_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transpile circuit using Qiskit Transpiler REST API\n",
    "\n",
    "Query the cloud Transpilation service at https://cloud-transpiler.quantum-computing.ibm.com/docs . See more details in the IBM Quantum Documentation guides on [\"Transpilation using REST API\"](https://docs.quantum.ibm.com/guides/transpile-rest-api). Note that [transpilation is now necessary](https://docs.quantum.ibm.com/announcements/product-updates/2024-02-14-qiskit-runtime-primitives-update) prior to submitting a circuit to IBM Quantum backends. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "backend='ibm_quebec'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "headers = {\n",
    "    \"accept\": \"application/json\",\n",
    "    \"Authorization\": f\"Bearer {token}\",\n",
    "    \"Content-Type\": \"application/json\",\n",
    "        }\n",
    "body= {\n",
    "    \"qasm_circuits\": qasm_string,\n",
    "}\n",
    "\n",
    "params = {\n",
    "    \"backend\": backend,\n",
    "    \"use_ai\": True,\n",
    "    \"optimization_level\": 1,\n",
    "    \"coupling_map\": [],\n",
    "    \"qiskit_transpile_options\": [],\n",
    "    \"ai_layout_mode\": 'OPTIMIZE', # 'KEEP', 'OPTIMIZE', 'IMPROVE',\n",
    "    }\n",
    "\n",
    "\n",
    "\n",
    "resp = requests.post(\n",
    "            \"https://cloud-transpiler.quantum.ibm.com/transpile\",\n",
    "            headers=headers,\n",
    "            json=body,\n",
    "            params = params,\n",
    "        )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "task_id=resp.json()['task_id']\n",
    "task_id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Request the transpilation service results using the task_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "res = requests.get(url=f\"https://cloud-transpiler.quantum.ibm.com/transpile/{task_id}\", headers=headers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OPENQASM 3.0; include \"stdgates.inc\"; gate rzx_140298706869648(_gate_p_0) _gate_q_0, _gate_q_1 {   h _gate_q_1; \n"
     ]
    }
   ],
   "source": [
    "if res.json().get(\"state\") == \"SUCCESS\":\n",
    "    resulting_qasm=res.json().get(\"result\")[0].get(\"qasm\")\n",
    "\n",
    "print(resulting_qasm[:112])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run Circuit using Runtime REST API\n",
    "\n",
    "Note the jobs below use [Qiskit Runtime V2 primitives](https://docs.quantum.ibm.com/api/migration-guides/v2-primitives).  \n",
    "\n",
    "Both SamplerV2 and EstimatorV2 take one or more primitive unified blocs (PUBs) as the input. Each PUB is a tuple that contains one circuit and the data broadcasted to that circuit, which can be multiple observables and parameters. Each PUB returns a result. More details on using the Runtime REST API can be found in the IBM Quantum Documentation guide on [\"Primitives with REST API\"](https://docs.quantum.ibm.com/guides/primitives-rest-api)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "url = 'https://api.quantum-computing.ibm.com/runtime/jobs'\n",
    "hub = '<YOUR HUB>'\n",
    "group = '<YOUR GROUP>'\n",
    "project = '<YOUR PROJECT>'\n",
    "\n",
    "headers = {\n",
    "    'Content-Type': 'application/json',\n",
    "    'x-access-token':auth_id,\n",
    "    'x-qx-client-application': 'qiskit-version-2/0.39.2/'+'your_application' #specifying the application you might be running from. For an actual Integration project, this option it is invaluable to know where jobs are coming from. At this time the \"qiskit-version-2/0.39.2/\" string is a necessary prefix.\n",
    "    }\n",
    "job_input = {\n",
    "    'program_id': 'estimator',\n",
    "    \"backend\": backend, \n",
    "    \"hub\": hub,\n",
    "    \"group\": group,\n",
    "    \"project\": project,\n",
    "    \"start_session\": \"False\", #set to False if you just need to run a single job.  \n",
    "    \"params\": {\n",
    "        \"pubs\": [ #primitive unified blocs (PUBs) containing one circuit each. c.f. https://docs.quantum.ibm.com/api/migration-guides/v2-primitives\n",
    "            [resulting_qasm, # QASM circuit\n",
    "             {\"IIZII\": 1, \"XIZZZ\": 2.3}, # Observable\n",
    "             None # parameter values\n",
    "             ]], \n",
    "        \"version\": 2 #this defines the version of the Qiskit Runtime Primitive to use, c.f. https://docs.quantum.ibm.com/api/migration-guides/v2-primitives\n",
    "}}\n",
    "\n",
    "response = requests.post(url, headers=headers, json=job_input)\n",
    "\n",
    "if response.status_code == 200:\n",
    "    job_id = response.json().get('id')\n",
    "    print(\"Job created:\",response.text)\n",
    "else:\n",
    "    print(f\"Error: {response.status_code}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### check job status"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'status': 'Completed', 'reason': '', 'reasonCode': None}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response_status_singlejob= requests.get(url+'/'+job_id, headers=headers)\n",
    "response_status_singlejob.json().get('state')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get job results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'data': {'evs': 0.5121617512921861, 'stds': 0.2692213349927506, 'ensemble_standard_error': 0.12655983446198443}, 'metadata': {'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32}}]\n"
     ]
    }
   ],
   "source": [
    "response_result= requests.get(url+'/'+job_id+'/results', headers=headers)\n",
    "\n",
    "res_dict=response_result.json()\n",
    "\n",
    "estimator_result=res_dict['results']\n",
    "print(estimator_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expectation value:  0.7428980350102542\n"
     ]
    }
   ],
   "source": [
    "exp_val=res_dict['results'][0]['data']['evs']\n",
    "print('Expectation value: ', exp_val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exploring Qiskit Runtime Options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    " \n",
    "url = 'https://api.quantum-computing.ibm.com/runtime/jobs'\n",
    "headers = {\n",
    "  'Content-Type': 'application/json',\n",
    "  'x-access-token':auth_id,\n",
    "  'x-qx-client-application': 'qiskit-version-2/0.39.2/'+'your_application' # specifying the application you might be running from. For an actual Integration project, this option is invaluable to know where jobs are coming from. At this time the \"qiskit-version-2/0.39.2/\" string is a necessary prefix.\n",
    "  }\n",
    "job_input = {\n",
    "  'program_id': 'estimator',\n",
    "  \"backend\": backend, \n",
    "  \"hub\": hub,\n",
    "  \"group\": group,\n",
    "  \"project\": project,\n",
    "  \"start_session\": \"False\", # set to False if you just need to run a single job.  \n",
    "  \"params\": { \n",
    "      \"pubs\": [ #primitive unified blocs (PUBs) containing one circuit each. c.f. https://docs.quantum.ibm.com/api/migration-guides/v2-primitives\n",
    "            [resulting_qasm, # QASM circuit\n",
    "             {\"IIZII\": 1, \"XIZZZ\": 2.3}, # Observable\n",
    "             None # parameter values\n",
    "             ]],  \n",
    "      \"version\": 2, # this defines the version of the Qiskit Runtime Primitive to use, c.f. https://docs.quantum.ibm.com/api/migration-guides/v2-primitives\n",
    "      \"options\": {\n",
    "          \"resilience\": {\n",
    "              \"measure_mitigation\": True,\n",
    "              \"zne_mitigation\": True,\n",
    "              \"zne\": {\n",
    "                  \"extrapolator\":[\"exponential\", \"linear\"],\n",
    "                  \"noise_factors\":[1, 3, 5],\n",
    "              },\n",
    "              #\"pec_mitigation\": False,\n",
    "              #\"pec\": None,\n",
    "              #\"layer_noise_learning\":None,\n",
    "          },\n",
    "          #\"dynamical_decoupling\": { \n",
    "          #    \"enable\": True,\n",
    "          #    \"sequence_type\": 'XpXm',\n",
    "          #    \"extra_slack_distribution\": 'middle',\n",
    "          #    \"scheduling_method\": 'alap',\n",
    "          #},\n",
    "          #\"twirling\": { \n",
    "          #    \"enable_gates\": True, \n",
    "          #    \"enable_measure\": True,\n",
    "          #    \"num_randomizations\": \"auto\",\n",
    "          #    \"shots_per_randomization\": \"auto\",\n",
    "          #    \"strategy\": \"active-accum\",\n",
    "          #    },\n",
    "              \n",
    "      },\n",
    "  }\n",
    "}\n",
    " \n",
    "response = requests.post(url, headers=headers, json=job_input)\n",
    " \n",
    "if response.status_code == 200:\n",
    "  job_id = response.json().get('id')\n",
    "  print(\"Job created:\",response.text)\n",
    "else:\n",
    "  print(f\"Error: {response.status_code}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "response_status_singlejob= requests.get(url+'/'+job_id, headers=headers)\n",
    "print(response_status_singlejob.json().get('state'))\n",
    "\n",
    "response_result= requests.get(url+'/'+job_id+'/results', headers=headers)\n",
    "\n",
    "res_dict=response_result.json()\n",
    "\n",
    "estimator_result=res_dict['results']\n",
    "print(estimator_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Execution Modes using REST API\n",
    "\n",
    "You can run your Qiskit primitive workloads using REST APIs in one of three execution modes, depending on your needs: job, session, and batch. More details on specific modes can be found in the IBM Quantum Documentation guide on [\"Execution Modes using REST API\"](https://docs.quantum.ibm.com/guides/execution-modes-rest-api). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Session Mode\n",
    "\n",
    "A session is a Qiskit Runtime feature that lets you efficiently run multi-job iterative workloads on quantum computers. \n",
    "\n",
    "#### Start a Session\n",
    "\n",
    "Begin with creating a session and obtaining a `sessionId`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    " \n",
    "sessionsUrl = \"https://api.quantum-computing.ibm.com/runtime/sessions\"\n",
    " \n",
    "headersList = {\n",
    "  \"Accept\": \"application/json\",\n",
    "  # \"Authorization\": \"Bearer \"+token,\n",
    "  'x-access-token':auth_id,\n",
    "  \"Content-Type\": \"application/json\" \n",
    "}\n",
    " \n",
    "instance_string = hub+'/'+group+'/'+project\n",
    "payload = {\n",
    "  \"backend\": backend,\n",
    "  \"instance\": instance_string,\n",
    "}\n",
    " \n",
    "response = requests.request(\"POST\", sessionsUrl, json=payload,  headers=headersList)\n",
    " \n",
    "sessionId = response.json()['id']\n",
    " \n",
    "print(response.json())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Submit job(s) against resulting Session ID"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "url = 'https://api.quantum-computing.ibm.com/runtime/jobs'\n",
    "headers = {\n",
    "    'Content-Type': 'application/json',\n",
    "    'x-access-token':auth_id,\n",
    "    'x-qx-client-application': 'qiskit-version-2/0.39.2/'+'your_application' #specifying the application you might be running from. For an actual Integration project, this option it is invaluable to know where jobs are coming from. At this time the \"qiskit-version-2/0.39.2/\" string is a necessary prefix.\n",
    "    }\n",
    "job_input = {\n",
    "    'program_id': 'estimator',\n",
    "    \"backend\": backend, \n",
    "    \"hub\": hub,\n",
    "    \"group\": group,\n",
    "    \"project\": project,\n",
    "    \"session_id\": sessionId, # This specifies the previously created Session\n",
    "    \"params\": {\n",
    "        \"pubs\": [[resulting_qasm,{\"II\": 1, \"ZZ\": 2.3},None,0.01]], #primitive unified blocs (PUBs) containing one circuit each. c.f. https://docs.quantum.ibm.com/api/migration-guides/v2-primitives\n",
    "        \"version\": 2, #this defines the version of the Qiskit Runtime Primitive to use, c.f. https://docs.quantum.ibm.com/api/migration-guides/v2-primitives\n",
    "        \"options\": {\n",
    "            \"transpilation\":{\"optimization_level\": 1},\n",
    "            \"resilience\": {\n",
    "                    \"measure_mitigation\": True, #c.f. documentation at https://docs.quantum.ibm.com/run/configure-error-mitigation#custom-error-settings-v2-primitives \n",
    "                #     # \"measure_noise_learning\": None,\n",
    "                #     # \"zne_mitigation\": None,\n",
    "                #     # \"zne\": None,\n",
    "                #     # \"pec_mitigation\": None,\n",
    "                #     # \"pec\": None,\n",
    "                #     # \"layer_noise_learning\": None,\n",
    "                    },\n",
    "            \"twirling\": {\"enable_gates\": True},\n",
    "            \"dynamical_decoupling\": {\"enable\": False},#, \"sequence_type\": \"XpXm\"},\n",
    "                     \n",
    "                },\n",
    "        # \"resilience_level\": 0,        \n",
    "    }\n",
    "        # \"circuits\": [resulting_qasm] #only use this input for Primitives V1, i.e. \"version\": 1\n",
    "}\n",
    "response = requests.post(url, headers=headers, json=job_input)\n",
    "\n",
    "if response.status_code == 200:\n",
    "    job_id_estimator = response.json().get('id')\n",
    "    print(\"Job created:\",response.text)\n",
    "else:\n",
    "    print(f\"Error: {response.status_code}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get the Job Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'status': 'Completed', 'reason': '', 'reasonCode': None}"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response_status= requests.get(url+'/'+job_id_estimator, headers=headers)\n",
    "response_status.json().get('state')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'data': {'evs': -1.3206712251052517, 'stds': 0.019759525689619355, 'ensemble_standard_error': 0.0200795395210333}, 'metadata': {'shots': 10016, 'target_precision': 0.01, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32}}]\n"
     ]
    }
   ],
   "source": [
    "response_estimator = requests.get(url+'/'+job_id_estimator+'/results', headers=headers)\n",
    "res_dict_estimator=response_estimator.json()\n",
    "\n",
    "print(res_dict_estimator['results'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expectation value:  -1.3206712251052517\n"
     ]
    }
   ],
   "source": [
    "exp_val=res_dict_estimator['results'][0]['data']['evs']\n",
    "print('Expectation value: ', exp_val)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Batch Mode\n",
    "\n",
    "Alternatively, you can submit a batch job by specifying the mode in the request payload. Batch mode can help shorten processing time if all jobs can be provided at the outset. More details about batch mode can be found in the documentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    " \n",
    "sessionsUrl = \"https://api.quantum-computing.ibm.com/runtime/sessions\"\n",
    " \n",
    "headersList = {\n",
    "  \"Accept\": \"application/json\",\n",
    "  'x-access-token':auth_id,\n",
    "  \"Content-Type\": \"application/json\" \n",
    "}\n",
    " \n",
    "instance_string = hub+'/'+group+'/'+project\n",
    "\n",
    "payload = json.dumps({\n",
    "  \"backend\": backend,\n",
    "  \"instance\": instance_string,\n",
    "  \"mode\": \"batch\"\n",
    "})\n",
    " \n",
    "response = requests.request(\"POST\", sessionsUrl, data=payload,  headers=headersList)\n",
    " \n",
    "sessionId = response.json()['id']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Close Session\n",
    "\n",
    "It is very good practice to close a Session when all jobs are done. This will reduce wait time for subsequent Users. More details can be found in the [documentation](https://docs.quantum.ibm.com/run/run-jobs-in-session)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Session closure response ok?: True \n"
     ]
    }
   ],
   "source": [
    "closureURL=\"https://api.quantum-computing.ibm.com/runtime/sessions/\"+sessionId+\"/close\"\n",
    "\n",
    "headersList = {\n",
    "  \"Accept\": \"application/json\",\n",
    "  # \"Authorization\": \"Bearer \"+token,\n",
    "  'x-access-token':auth_id,\n",
    "}\n",
    " \n",
    "closure_response = requests.request(\n",
    "    \"DELETE\",\n",
    "    closureURL, \n",
    "    headers=headersList)\n",
    "\n",
    "print(\"Session closure response ok?:\",closure_response.ok,closure_response.text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (Optional) Invalidate Token "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "response ok?: True \n"
     ]
    }
   ],
   "source": [
    "logout_url = 'https://auth.quantum-computing.ibm.com/api/users/logout'\n",
    "headers = {'x-access-token':auth_id}\n",
    "logout_response = requests.post(logout_url, headers=headers)\n",
    "print(\"response ok?:\",logout_response.ok,logout_response.text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (Optional) Test Token Invalidation\n",
    "\n",
    "This should yield an Authoritzation error (Error 401) once access token is invalidated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "invalid credentials. Access token should be successfully invalidated.\n"
     ]
    }
   ],
   "source": [
    "logout_url = 'https://auth.quantum-computing.ibm.com/api/users/logout'\n",
    "headers = {'x-access-token':auth_id}\n",
    "logout_response = requests.post(logout_url, headers=headers)\n",
    "\n",
    "if logout_response.status_code == 200:\n",
    "    job_id = logout_response.json().get('id')\n",
    "    print(\"Job created:\",logout_response.text)\n",
    "elif logout_response.status_code == 401:\n",
    "    print(\"invalid credentials. Access token should be successfully invalidated.\")\n",
    "else:\n",
    "    print(logout_response.text,\"\\n\")\n",
    "    print(f\"Error: {logout_response.status_code}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "qiskitEnvironment",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "1f34ebf922ea70f2437b8214c42897c80e17c505733c5bc7beb7fdf0e25edb45"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}