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

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

CLIENT_ID=<command to obtain your client_id>
CLIENT_SECRET=<secure command to obtain your client_secret>
AUDIENCE="https://fleet-api.prd.cn.vn.cloud.tesla.cn"
# 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.cn/oauth2/v3/token'

https://auth.tesla.cn/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.cn/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.cn/oauth2/v3/token'

https://auth.tesla.cn/user/revoke/consent?revoke_client_id=cb30fbdf81e9-4405-ba59-ddbc042277e8&back_url=https://accounts.tesla.cn/account-settings/security?tab=tpty-apps

curl --request POST \
  --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/backup' 

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

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

fetch("https://fleet-api.prd.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/backup", 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.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/backup")

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"

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

import os
import http.client
import json

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

 点击查看成功回复
{
 "response": {
  "code": 201,
  "message": "Updated"
 }
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/calendar_history?kind=backup&=null' 

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.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/calendar_history?kind=backup&", 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.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/calendar_history?kind=backup&")

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.cn.vn.cloud.tesla.cn")
payload = ''
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("GET", "/api/1/energy_sites/{energy_site_id}/calendar_history?kind=backup&=null", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 点击查看成功回复
{
 "response": {
  "events": [
   {
    "timestamp": "2023-01-01T01:00:00-08:00",
    "duration": 3600
   },
   {
    "timestamp": "2023-01-02T08:00:00-08:00",
    "duration": 7200
   }
  ],
  "total_events": 2
 }
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/telemetry_history?kind=charge&=null' 

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.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/telemetry_history?kind=charge&", 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.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/telemetry_history?kind=charge&")

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.cn.vn.cloud.tesla.cn")
payload = ''
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("GET", "/api/1/energy_sites/{energy_site_id}/telemetry_history?kind=charge&=null", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 点击查看成功回复
{
 "response": {
  "charge_history": [
   {
    "charge_start_time": {
     "seconds": 1672560000
    },
    "charge_duration": {
     "seconds": 12000
    },
    "energy_added_wh": 25000
   }
  ]
 }
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/calendar_history?kind=energy&=null' 

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.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/calendar_history?kind=energy&", 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.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/calendar_history?kind=energy&")

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.cn.vn.cloud.tesla.cn")
payload = ''
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("GET", "/api/1/energy_sites/{energy_site_id}/calendar_history?kind=energy&=null", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 点击查看成功回复
{
 "response": {
  "period": "day",
  "time_series": [
   {
    "timestamp": "2023-06-01T01:00:00-07:00",
    "solar_energy_exported": 70940,
    "generator_energy_exported": 0,
    "grid_energy_imported": 521,
    "grid_services_energy_imported": 17.53125,
    "grid_services_energy_exported": 3.80859375,
    "grid_energy_exported_from_solar": 43660,
    "grid_energy_exported_from_generator": 0,
    "grid_energy_exported_from_battery": 19,
    "battery_energy_exported": 10030,
    "battery_energy_imported_from_grid": 80,
    "battery_energy_imported_from_solar": 16800,
    "battery_energy_imported_from_generator": 0,
    "consumer_energy_imported_from_grid": 441,
    "consumer_energy_imported_from_solar": 10480,
    "consumer_energy_imported_from_battery": 10011,
    "consumer_energy_imported_from_generator": 0
   }
  ]
 }
}

curl --request POST \
  --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/grid_import_export' 

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

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

fetch("https://fleet-api.prd.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/grid_import_export", 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.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/grid_import_export")

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"

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

import os
import http.client
import json

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

 点击查看成功回复
{
 "response": {
  "code": 204,
  "message": "Updated"
 }
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/live_status' 

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.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/live_status", 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.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/live_status")

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.cn.vn.cloud.tesla.cn")
payload = ''
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("GET", "/api/1/energy_sites/{energy_site_id}/live_status", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 点击查看成功回复
{
 "response": {
  "solar_power": 3102,
  "energy_left": 18020.894736842107,
  "total_pack_energy": 39343,
  "percentage_charged": 45.80457701965307,
  "backup_capable": true,
  "battery_power": -3090,
  "load_power": 2581,
  "grid_status": "Active",
  "grid_power": 2569,
  "island_status": "on_grid",
  "storm_mode_active": false,
  "timestamp": "2023-01-01T00:00:00-08:00"
 }
}

curl --request POST \
  --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/off_grid_vehicle_charging_reserve' 

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

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

fetch("https://fleet-api.prd.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/off_grid_vehicle_charging_reserve", 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.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/off_grid_vehicle_charging_reserve")

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"

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

import os
import http.client
import json

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

 点击查看成功回复
{
 "response": {
  "code": 201,
  "message": "Updated"
 }
}

curl --request POST \
  --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/operation' 

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

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

fetch("https://fleet-api.prd.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/operation", 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.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/operation")

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"

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

import os
import http.client
import json

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

 点击查看成功回复
{
 "response": {
  "code": 201,
  "message": "Updated"
 }
}

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

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.cn.vn.cloud.tesla.cn/api/1/products", 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.cn.vn.cloud.tesla.cn/api/1/products")

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.cn.vn.cloud.tesla.cn")
payload = ''
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("GET", "/api/1/products", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 点击查看成功回复
{
 "response": [
  {
   "id": 100021,
   "user_id": 429511308124,
   "vehicle_id": 99999,
   "vin": "5YJ3000000NEXUS01",
   "color": null,
   "access_type": "OWNER",
   "display_name": "Owned",
   "option_codes": "TEST0,COUS",
   "cached_data": null,
   "granular_access": {
    "hide_private": false
   },
   "tokens": [
    "4f993c5b9e2b937b",
    "7a3153b1bbb48a96"
   ],
   "state": null,
   "in_service": false,
   "id_s": "100021",
   "calendar_enabled": false,
   "api_version": null,
   "backseat_token": null,
   "backseat_token_updated_at": null,
   "command_signing": "off"
  },
  {
   "energy_site_id": 429124,
   "resource_type": "battery",
   "site_name": "My Home",
   "id": "STE12345678-12345",
   "gateway_id": "1112345-00-E--TG0123456789",
   "energy_left": 35425,
   "total_pack_energy": 39362,
   "percentage_charged": 90,
   "battery_power": 1000
  }
 ],
 "count": 2
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/site_info' 

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.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/site_info", 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.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/site_info")

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.cn.vn.cloud.tesla.cn")
payload = ''
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("GET", "/api/1/energy_sites/{energy_site_id}/site_info", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 点击查看成功回复
{
 "response": {
  "id": "0000000-00-A--TEST0000000DIN",
  "site_name": "My Home",
  "backup_reserve_percent": 20,
  "default_real_mode": "autonomous",
  "installation_date": "2023-01-01T00:00:00-08:00",
  "user_settings": {
   "storm_mode_enabled": true
  },
  "components": {
   "solar": true,
   "solar_type": "pv_panel",
   "battery": true,
   "grid": true,
   "backup": true,
   "load_meter": true,
   "storm_mode_capable": true,
   "off_grid_vehicle_charging_reserve_supported": true,
   "solar_value_enabled": true,
   "set_islanding_mode_enabled": true,
   "battery_type": "ac_powerwall",
   "configurable": true
  },
  "version": "23.12.11 452c76cb",
  "battery_count": 3,
  "nameplate_power": 15000,
  "nameplate_energy": 40500,
  "installation_time_zone": "America/Los_Angeles",
  "max_site_meter_power_ac": 1000000000,
  "min_site_meter_power_ac": -11.726
 }
}

curl --request POST \
  --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/storm_mode' 

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

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

fetch("https://fleet-api.prd.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/storm_mode", 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.cn.vn.cloud.tesla.cn/api/1/energy_sites/{energy_site_id}/storm_mode")

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"

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

import os
import http.client
import json

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

 点击查看成功回复
{
 "response": {
  "code": 201,
  "message": "Updated"
 }
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.cn.vn.cloud.tesla.cn/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.cn.vn.cloud.tesla.cn/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.cn.vn.cloud.tesla.cn/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.cn.vn.cloud.tesla.cn")
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"))

 点击查看成功回复
{
 "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.cn.vn.cloud.tesla.cn/api/1/dx/charging/invoice/{id}' 

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.cn.vn.cloud.tesla.cn/api/1/dx/charging/invoice/{id}", 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.cn.vn.cloud.tesla.cn/api/1/dx/charging/invoice/{id}")

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.cn.vn.cloud.tesla.cn")
payload = ''
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("GET", "/api/1/dx/charging/invoice/{id}", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 点击查看成功回复
{
 "response": "raw .pdf document"
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.cn.vn.cloud.tesla.cn/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.cn.vn.cloud.tesla.cn/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.cn.vn.cloud.tesla.cn/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.cn.vn.cloud.tesla.cn")
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"))

 点击查看成功回复
{
 "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.cn.vn.cloud.tesla.cn/api/1/partner_accounts/fleet_telemetry_errors' 

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.cn.vn.cloud.tesla.cn/api/1/partner_accounts/fleet_telemetry_errors", 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.cn.vn.cloud.tesla.cn/api/1/partner_accounts/fleet_telemetry_errors")

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.cn.vn.cloud.tesla.cn")
payload = ''
headers = {
   'Content-Type': 'application/json',
   'Authorization': 'Bearer ENV_TESLA_API_TOKEN'
}
conn.request("GET", "/api/1/partner_accounts/fleet_telemetry_errors", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

 点击查看成功回复
{
 "response": {
  "fleet_telemetry_errors": [
   {
    "name": "client-id",
    "error": "msg",
    "vin": "vin"
   },
   {
    "name": "client-id",
    "error": "msg2",
    "vin": "vin"
   }
  ]
 }
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.cn.vn.cloud.tesla.cn/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.cn.vn.cloud.tesla.cn/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.cn.vn.cloud.tesla.cn/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.cn.vn.cloud.tesla.cn")
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"))

 点击查看成功回复
{
 "response": {
  "public_key": "0437d832a7a695151f5a671780a276aa4cf2d6be3b2786465397612a342fcf418e98022d3cedf4e9a6f4b3b160472dee4ca022383d9b4cc4001a0f3023caec58fa"
 }
}

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

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

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

fetch("https://fleet-api.prd.cn.vn.cloud.tesla.cn/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.cn.vn.cloud.tesla.cn/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"

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

import os
import http.client
import json

conn = http.client.HTTPSConnection("fleet-api.prd.cn.vn.cloud.tesla.cn")
payload = ''
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"))

 点击查看成功回复
{
 "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": "discovery",
  "account_id": "account-id",
  "issuer": null,
  "csr": "-----BEGIN CERTIFICATE REQUEST-----\nMIHZMIGBAgEAMB8xHTAbBgNVBAMMFHRoZS1iZXN0LXBhcnRuZXIuY29tMFkwEwYH\nKoZIzj0CAQYIKoZIzj0DAQcDQgAEN9gyp6aVFR9aZxeAonaqTPLWvjsnhkZTl2Eq\nNC/PQY6YAi087fTppvSzsWBHLe5MoCI4PZtMxAAaDzAjyuxY+qAAMAoGCCqGSM49\nBAMCA0cAMEQCIE7LtTJO/Vrbr97cMz+FyjmzJ5FA+Xck55/QOnPq9AsOAiB77g0W\noEFqpvbpUQ1Y7biEoPa1gT0/nvoB31suLABmMg==\n-----END CERTIFICATE REQUEST-----\n",
  "csr_updated_at": "2023-06-28T00:42:00.000Z",
  "public_key": "0437d832a7a695151f5a671780a276aa4cf2d6be3b2786465397612a342fcf418e98022d3cedf4e9a6f4b3b160472dee4ca022383d9b4cc4001a0f3023caec58fa"
 }
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.cn.vn.cloud.tesla.cn/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.cn.vn.cloud.tesla.cn/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.cn.vn.cloud.tesla.cn/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.cn.vn.cloud.tesla.cn")
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"))

 点击查看成功回复
{
 "response": {
  "signaling": {
   "enabled": true,
   "subscribe_connectivity": false,
   "use_auth_token": false
  }
 }
}

curl --header 'Content-Type: application/json' \
  --header "Authorization: Bearer $TESLA_API_TOKEN" \
  'https://fleet-api.prd.cn.vn.cloud.tesla.cn/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.cn.vn.cloud.tesla.cn/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.cn.vn.cloud.tesla.cn/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