CLIENT_ID=<command to obtain your client_id>
CLIENT_SECRET=<secure command to obtain your client_secret>
AUDIENCE="https://fleet-api.prd.na.vn.cloud.tesla.com"
# Partner authentication token request
curl --request POST \
  --header 'Content-Type: application/x-www-form-urlencoded' \
  --data-urlencode 'grant_type=client_credentials' \
  --data-urlencode "client_id=$CLIENT_ID" \
  --data-urlencode "client_secret=$CLIENT_SECRET" \
  --data-urlencode 'scope=openid vehicle_device_data vehicle_cmds vehicle_charging_cmds' \
  --data-urlencode "audience=$AUDIENCE" \
  'https://auth.tesla.com/oauth2/v3/token'

https://auth.tesla.com/oauth2/v3/authorize?&client_id=$CLIENT_ID&locale=en-US&prompt=login&redirect_uri=$REDIRECT_URI&response_type=code&scope=openid%20vehicle_device_data%20offline_access&state=$STATE`

# Authorization code token request
CODE=<extract from callback>
curl --request POST \
  --header 'Content-Type: application/x-www-form-urlencoded' \
  --data-urlencode 'grant_type=authorization_code' \
  --data-urlencode "client_id=$CLIENT_ID" \
  --data-urlencode "client_secret=$CLIENT_SECRET" \
  --data-urlencode "code=$CODE" \
  --data-urlencode "audience=$AUDIENCE" \
  --data-urlencode "redirect_uri=$CALLBACK" \
  'https://auth.tesla.com/oauth2/v3/token'
# Extract access_token and refresh_token from this response

# Refresh token request
REFRESH_TOKEN=<extract from authorization code token request>
curl --request POST \
  --header 'Content-Type: application/x-www-form-urlencoded' \
  --data-urlencode 'grant_type=refresh_token' \
  --data-urlencode "client_id=$CLIENT_ID" \
  --data-urlencode "refresh_token=$REFRESH_TOKEN" \
  'https://auth.tesla.com/oauth2/v3/token'

  Content-Type: application/json
  Authorization: Bearer 8s2wfclhyp5iiikowm3ocnfalt7qfl7es8xhuda3ttusslssx6c14hq7yocp62c5

curl 'https://fleet-api.prd.na.vn.cloud.tesla.com/status'

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/dx/charging/history' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const requestOptions = {
   method: 'GET',
   headers: myHeaders,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/dx/charging/history", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/dx/charging/history")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = ''
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("GET", "/api/1/dx/charging/history", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "data": [
  {
   "sessionId": 1234567,
   "vin": "TEST00000000VIN01",
   "siteLocationName": "Truckee, CA - Soaring Way",
   "chargeStartDateTime": "2023-07-27T11:43:45-07:00",
   "chargeStopDateTime": "2023-07-27T12:08:35-07:00",
   "unlatchDateTime": "2023-07-27T12:25:31-07:00",
   "countryCode": "US",
   "fees": [
    {
     "sessionFeeId": 7654321,
     "feeType": "CHARGING",
     "currencyCode": "USD",
     "pricingType": "PAYMENT",
     "rateBase": 0.46,
     "rateTier1": 0,
     "rateTier2": 0,
     "rateTier3": null,
     "rateTier4": null,
     "usageBase": 40,
     "usageTier1": 0,
     "usageTier2": 24,
     "usageTier3": null,
     "usageTier4": null,
     "totalBase": 18.4,
     "totalTier1": 0,
     "totalTier2": 0,
     "totalTier3": 0,
     "totalTier4": 0,
     "totalDue": 18.4,
     "netDue": 18.4,
     "uom": "kwh",
     "isPaid": true,
     "status": "PAID"
    },
    {
     "sessionFeeId": 87654321,
     "feeType": "PARKING",
     "currencyCode": "USD",
     "pricingType": "NO_CHARGE",
     "rateBase": 0,
     "rateTier1": 0,
     "rateTier2": 0,
     "rateTier3": null,
     "rateTier4": null,
     "usageBase": 0,
     "usageTier1": 0,
     "usageTier2": 0,
     "usageTier3": null,
     "usageTier4": null,
     "totalBase": 0,
     "totalTier1": 0,
     "totalTier2": 0,
     "totalTier3": 0,
     "totalTier4": 0,
     "totalDue": 0,
     "netDue": 0,
     "uom": "min",
     "isPaid": true,
     "status": "PAID"
    }
   ],
   "billingType": "IMMEDIATE",
   "invoices": [
    {
     "fileName": "ABC-123NN-US.pdf",
     "contentId": "abc-123-efg",
     "invoiceType": "IMMEDIATE"
    }
   ],
   "vehicleMakeType": "TSLA"
  }
 ]
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/dx/charging/sessions' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const requestOptions = {
   method: 'GET',
   headers: myHeaders,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/dx/charging/sessions", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/dx/charging/sessions")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = ''
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("GET", "/api/1/dx/charging/sessions", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "data": [
  {
   "charging_periods": [
    {
     "dimensions": [
      {
       "type": "ENERGY",
       "volume": 0
      }
     ],
     "start_date_time": "string"
    }
   ],
   "id": "string",
   "location": {
    "country": "string",
    "name": "string"
   },
   "model": "string",
   "start_date_time": "string",
   "stop_date_time": "string",
   "tariffs": {
    "currency": "string",
    "elements": [
     {
      "price_components": [
       {
        "price": 0,
        "step_size": 0,
        "type": "ENERGY"
       }
      ],
      "restrictions": {
       "additionalProp1": {}
      }
     }
    ]
   },
   "total_cost": {
    "excl_vat": 0,
    "incl_vat": 0,
    "vat": 0
   },
   "total_energy": 0,
   "total_time": 0,
   "vin": "string"
  }
 ],
 "status_code": 0,
 "status_message": "string",
 "timestamp": {
  "time.Time": "string"
 }
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/partner_accounts/public_key' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const requestOptions = {
   method: 'GET',
   headers: myHeaders,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/partner_accounts/public_key", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/partner_accounts/public_key")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = ''
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("GET", "/api/1/partner_accounts/public_key", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "public_key": "04b3ba29bfed422f4a641630333458428cbd681ae1456f1d50521852577c3a84b22c7290087af38d8c4cd7b310dbfd79f164405d72a6cfac875ca37a7f09317891"
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  --data '{"domain":"string"}' \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/partner_accounts' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const body = JSON.stringify({
   "domain": "string"
});

const requestOptions = {
   method: 'POST',
   headers: myHeaders,
   body,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/partner_accounts", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/partner_accounts")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"
request.body = JSON.dump({
   "domain": "string"
})

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = json.dumps({
   "domain": "string"
})
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("POST", "/api/1/partner_accounts", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "client_id": "client-id",
 "name": "The Best Tesla Partner",
 "description": "The very best Tesla partner",
 "domain": "the-best-partner.com",
 "ca": null,
 "created_at": "2023-06-28T00:42:00.000Z",
 "updated_at": "2023-06-28T00:42:00.000Z",
 "enterprise_tier": "free",
 "public_key": "04b3ba29bfed422f4a641630333458428cbd681ae1456f1d50521852577c3a84b22c7290087af38d8c4cd7b310dbfd79f164405d72a6cfac875ca37a7f09317891"
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/users/backup_key' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const requestOptions = {
   method: 'GET',
   headers: myHeaders,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/users/backup_key", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/users/backup_key")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = ''
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("GET", "/api/1/users/backup_key", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "backup_key": null
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/users/feature_config' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const requestOptions = {
   method: 'GET',
   headers: myHeaders,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/users/feature_config", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/users/feature_config")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = ''
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("GET", "/api/1/users/feature_config", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "signaling": {
  "enabled": true,
  "subscribe_connectivity": false
 }
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/users/me' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const requestOptions = {
   method: 'GET',
   headers: myHeaders,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/users/me", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/users/me")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = ''
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("GET", "/api/1/users/me", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "email": "test-user@tesla.com",
 "full_name": "Testy McTesterson",
 "profile_image_url": "https://vehicle-files.prd.usw2.vn.cloud.tesla.com/profile_images/f98c87cd7bebc06069b89b33f9ec634c195520f75b6e63ea89f0b7c61449c689.jpg"
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/users/orders' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const requestOptions = {
   method: 'GET',
   headers: myHeaders,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/users/orders", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/users/orders")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = ''
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("GET", "/api/1/users/orders", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
[
 {
  "vehicleMapId": 1234466,
  "referenceNumber": "RN00000001",
  "vin": "5YJ30000000000001",
  "orderStatus": "BOOKED",
  "orderSubstatus": "_Z",
  "modelCode": "m3",
  "countryCode": "US",
  "locale": "en_US",
  "mktOptions": "APBS,DV2W,IBB1,PMNG,PRM30,SC04,MDL3,W41B,MT322,CPF0,RSF1,CW03",
  "isB2b": false
 }
]

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/users/region' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const requestOptions = {
   method: 'GET',
   headers: myHeaders,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/users/region", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/users/region")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = ''
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("GET", "/api/1/users/region", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "region": "eu",
 "fleet_api_base_url": "https://fleet-api.prd.eu.vn.cloud.tesla.com"
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  --data '{"which_trunk":"string"}' \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/actuate_trunk' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const body = JSON.stringify({
   "which_trunk": "string"
});

const requestOptions = {
   method: 'POST',
   headers: myHeaders,
   body,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/actuate_trunk", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/actuate_trunk")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"
request.body = JSON.dump({
   "which_trunk": "string"
})

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = json.dumps({
   "which_trunk": "string"
})
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("POST", "/api/1/vehicles/{id}/command/actuate_trunk", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "result": true,
 "reason": ""
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  --data '{"volume":"number"}' \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/adjust_volume' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const body = JSON.stringify({
   "volume": "number"
});

const requestOptions = {
   method: 'POST',
   headers: myHeaders,
   body,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/adjust_volume", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/adjust_volume")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"
request.body = JSON.dump({
   "volume": "number"
})

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = json.dumps({
   "volume": "number"
})
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("POST", "/api/1/vehicles/{id}/command/adjust_volume", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "result": true,
 "reason": ""
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  --data '{}' \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/auto_conditioning_start' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const body = JSON.stringify({});

const requestOptions = {
   method: 'POST',
   headers: myHeaders,
   body,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/auto_conditioning_start", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/auto_conditioning_start")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"
request.body = JSON.dump({})

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = json.dumps({})
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("POST", "/api/1/vehicles/{id}/command/auto_conditioning_start", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "result": true,
 "reason": ""
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  --data '{}' \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/auto_conditioning_stop' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const body = JSON.stringify({});

const requestOptions = {
   method: 'POST',
   headers: myHeaders,
   body,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/auto_conditioning_stop", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/auto_conditioning_stop")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"
request.body = JSON.dump({})

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = json.dumps({})
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("POST", "/api/1/vehicles/{id}/command/auto_conditioning_stop", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "result": true,
 "reason": ""
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  --data '{}' \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/cancel_software_update' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const body = JSON.stringify({});

const requestOptions = {
   method: 'POST',
   headers: myHeaders,
   body,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/cancel_software_update", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/cancel_software_update")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"
request.body = JSON.dump({})

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = json.dumps({})
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("POST", "/api/1/vehicles/{id}/command/cancel_software_update", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "result": true,
 "reason": ""
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  --data '{}' \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_max_range' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const body = JSON.stringify({});

const requestOptions = {
   method: 'POST',
   headers: myHeaders,
   body,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_max_range", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_max_range")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"
request.body = JSON.dump({})

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = json.dumps({})
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("POST", "/api/1/vehicles/{id}/command/charge_max_range", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "result": true,
 "reason": ""
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  --data '{}' \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_port_door_close' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const body = JSON.stringify({});

const requestOptions = {
   method: 'POST',
   headers: myHeaders,
   body,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_port_door_close", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_port_door_close")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"
request.body = JSON.dump({})

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = json.dumps({})
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("POST", "/api/1/vehicles/{id}/command/charge_port_door_close", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "result": true,
 "reason": ""
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  --data '{}' \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_port_door_open' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const body = JSON.stringify({});

const requestOptions = {
   method: 'POST',
   headers: myHeaders,
   body,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_port_door_open", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_port_door_open")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"
request.body = JSON.dump({})

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = json.dumps({})
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("POST", "/api/1/vehicles/{id}/command/charge_port_door_open", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "result": true,
 "reason": ""
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  --data '{}' \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_standard' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const body = JSON.stringify({});

const requestOptions = {
   method: 'POST',
   headers: myHeaders,
   body,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_standard", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_standard")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"
request.body = JSON.dump({})

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = json.dumps({})
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("POST", "/api/1/vehicles/{id}/command/charge_standard", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "result": true,
 "reason": ""
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  --data '{}' \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_start' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const body = JSON.stringify({});

const requestOptions = {
   method: 'POST',
   headers: myHeaders,
   body,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_start", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_start")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"
request.body = JSON.dump({})

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = json.dumps({})
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("POST", "/api/1/vehicles/{id}/command/charge_start", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "result": true,
 "reason": ""
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  --data '{}' \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_stop' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const body = JSON.stringify({});

const requestOptions = {
   method: 'POST',
   headers: myHeaders,
   body,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_stop", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/charge_stop")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"
request.body = JSON.dump({})

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = json.dumps({})
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("POST", "/api/1/vehicles/{id}/command/charge_stop", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 Click to view successful response
{
 "result": true,
 "reason": ""
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  --data '{}' \
  'https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/clear_pin_to_drive_admin' 

const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("Authorization", `Bearer ${process.env.TESLA_API_TOKEN}`);

const body = JSON.stringify({});

const requestOptions = {
   method: 'POST',
   headers: myHeaders,
   body,
   redirect: 'follow'
};

fetch("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/clear_pin_to_drive_admin", requestOptions)
   .then(response => response.json())
   .then(result => console.log(result))
   .catch(error => console.log('error', error));

require "uri"
require "json"
require "net/http"

url = URI("https://fleet-api.prd.na.vn.cloud.tesla.com/api/1/vehicles/{id}/command/clear_pin_to_drive_admin")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer ENV_TESLA_API_TOKEN"
request.body = JSON.dump({})

response = https.request(request)
puts response.read_body

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.na.vn.cloud.tesla.com")
payload = json.dumps({})
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("POST", "/api/1/vehicles/{id}/command/clear_pin_to_drive_admin", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))