Release Notes and Announcements
Announcements
Product Introduction
Glossary
Product Overview
Review Standards
Notes
Signature Review Standards
Body Template Review Standards
Sample Body Templates
Reasons for Rejection
Global SMS
Global SMS Intro
Global SMS Pricing
Getting Started
Console Guide
Console Overview
Global SMS
Marketing Management
Business Statistics
Application Management
General Management
Access Management
Practical Tutorial
How to Send Bulk Best Wishes Messages
How to Send SMS Verification Codes
API Documentation
History
Introduction
API Category
Making API Requests
Status Pull APIs
SMS Statistics APIs
SMS Signature APIs
SMS Delivery APIs
SMS Mobile Number APIs
SMS Conversion Rate APIs
SMS Template APIs
Data Types
Error Codes
SMS Callback APIs
SDK Documentation
SDK Download
SDK for Java
SDK for PHP
SDK for Python
SDK for Node.js
SDK for C#
SDK for Go
SDK for C++
FAQ
Billing
Security
Signature
Template
Message Content
Others
Service Agreement
Tencent Cloud SMS Data Processing and Security Agreement
Tencent Cloud SMS Privacy Policy
Service Level Agreement
Tencent Cloud SMS Services Terms of Service
SDK for Go

Focus Mode
Font Size
Last updated: 2024-12-13 15:51:09
SDK 3.0 is a companion tool for the TencentCloud API 3.0 platform. You can use all SMS APIs through the SDK. The new SDK version is unified and features the same SDK usage, API call methods, error codes, and returned packet formats for different programming languages.
Note: 
SMS sending APIs
One message can be sent to up to 200 numbers at a time.
Signature and body template APIs
Individual users have no permission to use signature and body template APIs and can manage SMS signatures and SMS body templates only in the SMS console. To use the APIs, change "Individual Identity" to "Organizational Identity".
Prerequisites
You have activated SMS. For detailed directions, please see Getting Started with Mainland China SMS.
If you need to send Mainland China SMS messages, you need to purchase a Mainland China SMS package first.
You have prepared the dependent environment: Go 1.9 or above.
You have obtained the SecretID and SecretKey on the API Key Management page in the CAM console.
SecretID is used to identify the API caller.
SecretKey is used to encrypt the string to sign that can be verified on the server. You should keep it private and avoid disclosure.
The endpoint of the SMS service is sms.tencentcloudapi.com.
Relevant Documents
For more information on the APIs and their parameters, please see API Documentation.
You can download the SDK source code here.
Installing SDK
Installing through go get (recommended)
We recommend you install the SDK by using the tool that comes with the language:
 go get -u github.com/tencentcloud/tencentcloud-sdk-go
Installing through source code
1. Go to the GitHub code hosting page or quick download address to download the latest code.
2. Decompress and install in the $GOPATH/src/github.com/tencentcloud directory.
Sample Code
Note: 
All samples are for reference only and cannot be directly compiled and executed. You need to modify them based on your actual needs. You can also use API 3.0 Explorer to automatically generate the demo code as needed.
Each API has a corresponding request structure and a response structure. This document only lists the sample code of several common features. 
Applying for SMS template
package main
﻿
import (
    "encoding/json"
    "fmt"
    "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common"
    "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/errors"
    "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile"
    sms "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/sms/v20190711"// Import SMS
)
﻿
func main() {
    /* Required steps:
     * Instantiate an authentication object. The Tencent Cloud account key pair `secretId` and `secretKey` need to be passed in as the input parameters
     * This example uses the way to read from the environment variable, so you need to set these two values in the environment variable in advance
     * You can also write the key pair directly into the code, but be careful not to copy, upload, or share the code to others
     * Query the CAM key: https://console.tencentcloud.com/cam/capi
     */
    credential := common.NewCredential(
        // os.Getenv("TENCENTCLOUD_SECRET_ID"),
        // os.Getenv("TENCENTCLOUD_SECRET_KEY"),
        "xxx",
        "xxx",
    )
    /* Optional steps:
     * Instantiate a client configuration object. You can specify the timeout period and other configuration items */
    cpf := profile.NewClientProfile()
﻿
    /* The SDK uses the POST method by default
     * If you need to use the GET method, you can set it here, but the GET method cannot handle some large requests */
    cpf.HttpProfile.ReqMethod = "POST"
﻿
    /* The SDK has a default timeout period. Do not adjust it unless absolutely necessary
     * If needed, check in the code to get the latest default value */
    //cpf.HttpProfile.ReqTimeout = 5
﻿
    /* The SDK automatically specifies the domain name. Generally, you don't need to specify a domain name, but if you are accessing a service in a finance AZ, you must manually specify the domain name
     * For example, the SMS domain name of the Shanghai Finance Zone is `sms.ap-shanghai-fsi.tencentcloudapi.com` */
    cpf.HttpProfile.Endpoint = "sms.tencentcloudapi.com"
﻿
    /* The SDK uses `TC3-HMAC-SHA256` to sign by default. Do not modify this field unless absolutely necessary */
    cpf.SignMethod = "HmacSHA1"
﻿
    /* Instantiate an SMS client object
     * The second parameter is the region information. You can directly enter the string `ap-guangzhou` or import the preset constant */
    client, _ := sms.NewClient(credential, "ap-guangzhou", cpf)
﻿
    /* Instantiate a request object. You can further set the request parameters according to the API called and actual conditions
    * You can directly check the SDK source code to determine which attributes of the API can be set
     * An attribute may be of a basic type or import another data structure
     * We recommend you use the IDE for development where you can easily redirect to and view the documentation of each API and data structure */
    request := sms.NewAddSmsTemplateRequest()
﻿
    /* Settings of a basic parameter:
     * The SDK uses the pointer style to specify parameters, so even for basic parameters, you need to use pointers to assign values to them
     * The SDK provides encapsulation functions for importing the pointers of basic parameters
     * Help link:
     * SMS console: https://console.tencentcloud.com/smsv2
     * sms helper：https://www.tencentcloud.com/document/product/382/3773?from_cn_redirect=1
     */
﻿
    /* Template name */
    request.TemplateName = common.StringPtr("Tencent Cloud")
    /* Template content */
    request.TemplateContent = common.StringPtr("Your login verification code is {1}. Please enter it within {2} minutes. If the login was not initiated by you, please ignore this message.")
    /* SMS type. 0: regular SMS; 1: marketing SMS */
    request.SmsType = common.Uint64Ptr(0)
    /* Whether it is Global SMS:
       0: Mainland China SMS
       1: Global SMS */
    request.International = common.Uint64Ptr(0)
    /* Template remarks, such as reason for application and use case */
    request.Remark = common.StringPtr("xxx")
﻿
    // Call the API you want to access through the client object. You need to pass in the request object
    response, err := client.AddSmsTemplate(request)
    // Handle the exception
    if _, ok := err.(*errors.TencentCloudSDKError); ok {
        fmt.Printf("An API error has returned: %s", err)
        return
    }
    // This is a direct failure instead of SDK exception. You can add other troubleshooting measures in the real code
    if err != nil {
        panic(err)
    }
    b, _ := json.Marshal(response.Response)
    // Print the returned JSON string
    fmt.Printf("%s", b)
}
Sending SMS message
package main
﻿
import (
    "encoding/json"
    "fmt"
﻿
    "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common"
    "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/errors"
    "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile"
    sms "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/sms/v20190711"// Import SMS
)
﻿
func main() {
    /* Required steps:
     * Instantiate an authentication object. The Tencent Cloud account key pair `secretId` and `secretKey` need to be passed in as the input parameters
     * This example uses the way to read from the environment variable, so you need to set these two values in the environment variable in advance
     * You can also write the key pair directly into the code, but be careful not to copy, upload, or share the code to others
     * Query the CAM key: https://console.tencentcloud.com/cam/capi
     */
    credential := common.NewCredential(
        // os.Getenv("TENCENTCLOUD_SECRET_ID"),
        // os.Getenv("TENCENTCLOUD_SECRET_KEY"),
        "xxx",
        "xxx",
    )
    /* Optional steps:
     * Instantiate a client configuration object. You can specify the timeout period and other configuration items */
    cpf := profile.NewClientProfile()
﻿
    /* The SDK uses the POST method by default
     * If you need to use the GET method, you can set it here, but the GET method cannot handle some large requests */
    cpf.HttpProfile.ReqMethod = "POST"
﻿
    /* The SDK has a default timeout period. Do not adjust it unless absolutely necessary
     * If needed, check in the code to get the latest default value */
    //cpf.HttpProfile.ReqTimeout = 5
﻿
    /* The SDK automatically specifies the domain name. Generally, you don't need to specify a domain name, but if you are accessing a service in a finance AZ, you must manually specify the domain name
     * For example, the SMS domain name of the Shanghai Finance Zone is `sms.ap-shanghai-fsi.tencentcloudapi.com` */
    cpf.HttpProfile.Endpoint = "sms.tencentcloudapi.com"
﻿
    /* The SDK uses `TC3-HMAC-SHA256` to sign by default. Do not modify this field unless absolutely necessary */
    cpf.SignMethod = "HmacSHA1"
﻿
    /* Instantiate an SMS client object
     * The second parameter is the region information. You can directly enter the string `ap-guangzhou` or import the preset constant */
    client, _ := sms.NewClient(credential, "ap-guangzhou", cpf)
﻿
    /* Instantiate a request object. You can further set the request parameters according to the API called and actual conditions
    * You can directly check the SDK source code to determine which attributes of the API can be set
     * An attribute may be of a basic type or import another data structure
     * We recommend you use the IDE for development where you can easily redirect to and view the documentation of each API and data structure */
    request := sms.NewSendSmsRequest()
﻿
    /* Settings of a basic parameter:
     * The SDK uses the pointer style to specify parameters, so even for basic parameters, you need to use pointers to assign values to them
     * The SDK provides encapsulation functions for importing the pointers of basic parameters
     * Help link:
     * SMS console: https://console.tencentcloud.com/smsv2
     * sms helper：https://www.tencentcloud.com/document/product/382/3773?from_cn_redirect=1
     */
﻿
    /* SMS application ID, which is the `SDKAppID` generated after an application is added in the [SMS console], such as 1400006666 */
    request.SmsSdkAppid = common.StringPtr("1400787878")
    /* SMS signature content, which should be encoded in UTF-8. You must enter an approved signature, which can be viewed in the [SMS console] */
    request.Sign = common.StringPtr("xxx")
    /* `senderid` for Global SMS, which is not activated by default. If you need to activate it, please contact [SMS Helper] for assistance. This parameter should be left empty for Mainland China SMS */
    request.SenderId = common.StringPtr("")
    /* User session content, which can carry context information such as user-side ID and will be returned as-is by the server */
    request.SessionContext = common.StringPtr("xxx")
    /* SMS code number extension, which is not activated by default. If you need to activate it, please contact [SMS Helper] */
    request.ExtendCode = common.StringPtr("")
    /* Template parameters. If there are no template parameters, leave it empty */
    request.TemplateParamSet = common.StringPtrs([]string{"0"})
    /* Template ID. You must enter the ID of an approved template, which can be viewed in the [SMS console] */
    request.TemplateID = common.StringPtr("449739")
    /* Target mobile number in the e.164 standard (+[country/region code][mobile number])
     * Example: +8613711112222, which has a + sign followed by 86 (country/region code) and then by 13711112222 (mobile number). Up to 200 mobile numbers are supported */
    request.PhoneNumberSet = common.StringPtrs([]string{"+8613711112222", "+8613711333222", "+8613711144422"})
﻿
﻿
    // Call the API you want to access through the client object. You need to pass in the request object
    response, err := client.SendSms(request)
    // Handle the exception
    if _, ok := err.(*errors.TencentCloudSDKError); ok {
        fmt.Printf("An API error has returned: %s", err)
        return
    }
    // This is a direct failure instead of SDK exception. You can add other troubleshooting measures in the real code
    if err != nil {
        panic(err)
    }
    b, _ := json.Marshal(response.Response)
    // Print the returned JSON string
    fmt.Printf("%s", b)
}
Pulling receipt status
package main
﻿
import (
    "encoding/json"
    "fmt"
﻿
    "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common"
    "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/errors"
    "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile"
    sms "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/sms/v20190711"// Import SMS
)
﻿
func main() {
    /* Required steps:
     * Instantiate an authentication object. The Tencent Cloud account key pair `secretId` and `secretKey` need to be passed in as the input parameters
     * This example uses the way to read from the environment variable, so you need to set these two values in the environment variable in advance
     * You can also write the key pair directly into the code, but be careful not to copy, upload, or share the code to others
     * Query the CAM key: https://console.tencentcloud.com/cam/capi
     */
    credential := common.NewCredential(
        // os.Getenv("TENCENTCLOUD_SECRET_ID"),
        // os.Getenv("TENCENTCLOUD_SECRET_KEY"),
        "xxx",
        "xxx",
    )
    /* Optional steps:
     * Instantiate a client configuration object. You can specify the timeout period and other configuration items */
    cpf := profile.NewClientProfile()
﻿
    /* The SDK uses the POST method by default
     * If you need to use the GET method, you can set it here, but the GET method cannot handle some large requests */
    cpf.HttpProfile.ReqMethod = "POST"
﻿
    /* The SDK has a default timeout period. Do not adjust it unless absolutely necessary
     * If needed, check in the code to get the latest default value */
    //cpf.HttpProfile.ReqTimeout = 5
﻿
    /* The SDK automatically specifies the domain name. Generally, you don't need to specify a domain name, but if you are accessing a service in a finance AZ, you must manually specify the domain name
     * For example, the SMS domain name of the Shanghai Finance Zone is `sms.ap-shanghai-fsi.tencentcloudapi.com` */
    cpf.HttpProfile.Endpoint = "sms.tencentcloudapi.com"
﻿
    /* The SDK uses `TC3-HMAC-SHA256` to sign by default
     * Do not modify this field unless absolutely necessary */
    cpf.SignMethod = "HmacSHA1"
﻿
    /* Instantiate an SMS client object
     * The second parameter is the region information. You can directly enter the string `ap-guangzhou` or import the preset constant */
    client, _ := sms.NewClient(credential, "ap-guangzhou", cpf)
﻿
    /* Instantiate a request object. You can further set the request parameters according to the API called and actual conditions
     * You can directly check the SDK source code to determine which attributes of the API can be set
     * An attribute may be of a basic type or import another data structure
     * We recommend you use the IDE for development where you can easily redirect to and view the documentation of each API and data structure */
    request := sms.NewPullSmsSendStatusRequest()
﻿
    /* Settings of a basic parameter:
     * The SDK uses the pointer style to specify parameters, so even for basic parameters, you need to use pointers to assign values to them
     * The SDK provides encapsulation functions for importing the pointers of basic parameters
     * Help link:
     * SMS console: https://console.tencentcloud.com/smsv2
     * sms helper：https://www.tencentcloud.com/document/product/382/3773?from_cn_redirect=1
     */
﻿
    /* SMS application ID, which is the `SDKAppID` generated after an application is added in the [SMS console], such as 1400006666 */
    request.SmsSdkAppid = common.StringPtr("1400787878")
    /* Maximum number of pulled entries. Maximum value: 100 */
    request.Limit = common.Uint64Ptr(10)
﻿
    // Call the API you want to access through the client object. You need to pass in the request object
    response, err := client.PullSmsSendStatus(request)
    // Handle the exception
    if _, ok := err.(*errors.TencentCloudSDKError); ok {
        fmt.Printf("An API error has returned: %s", err)
        return
    }
    // This is a direct failure instead of SDK exception. You can add other troubleshooting measures in the real code
    if err != nil {
        panic(err)
    }
    b, _ := json.Marshal(response.Response)
    // Print the returned JSON string
    fmt.Printf("%s", b)
}
Collecting SMS message sending data
package main
﻿
import (
    "encoding/json"
    "fmt"
    "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common"
    "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/errors"
    "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile"
    sms "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/sms/v20190711" // Import SMS
)
﻿
func main() {
    /* Required steps:
     * Instantiate an authentication object. The Tencent Cloud account key pair `secretId` and `secretKey` need to be passed in as the input parameters
     * This example uses the way to read from the environment variable, so you need to set these two values in the environment variable in advance
     * You can also write the key pair directly into the code, but be careful not to copy, upload, or share the code to others
     * Query the CAM key: https://console.tencentcloud.com/cam/capi
     */
    credential := common.NewCredential(
        // os.Getenv("TENCENTCLOUD_SECRET_ID"),
        // os.Getenv("TENCENTCLOUD_SECRET_KEY"),
        "xxx",
        "xxx",
    )
    /* Optional steps:
     * Instantiate a client configuration object. You can specify the timeout period and other configuration items */
    cpf := profile.NewClientProfile()
﻿
    /* The SDK uses the POST method by default
     * If you need to use the GET method, you can set it here, but the GET method cannot handle some large requests */
    cpf.HttpProfile.ReqMethod = "POST"
﻿
    /* The SDK has a default timeout period. Do not adjust it unless absolutely necessary
     * If needed, check in the code to get the latest default value */
    //cpf.HttpProfile.ReqTimeout = 5
﻿
    /* The SDK automatically specifies the domain name. Generally, you don't need to specify a domain name, but if you are accessing a service in a finance AZ, you must manually specify the domain name
     * For example, the SMS domain name of the Shanghai Finance Zone is `sms.ap-shanghai-fsi.tencentcloudapi.com` */
    cpf.HttpProfile.Endpoint = "sms.tencentcloudapi.com"
﻿
    /* The SDK uses `TC3-HMAC-SHA256` to sign by default
     * Do not modify this field unless absolutely necessary */
    cpf.SignMethod = "HmacSHA1"
﻿
    /* Instantiate an SMS client object
     * The second parameter is the region information. You can directly enter the string `ap-guangzhou` or import the preset constant */
    client, _ := sms.NewClient(credential, "ap-guangzhou", cpf)
﻿
    /* Instantiate a request object. You can further set the request parameters according to the API called and actual conditions
     * You can directly check the SDK source code to determine which attributes of the API can be set
     * An attribute may be of a basic type or import another data structure
     * We recommend you use the IDE for development where you can easily redirect to and view the documentation of each API and data structure */
    request := sms.NewSendStatusStatisticsRequest()
﻿
    /* Settings of a basic parameter:
     * The SDK uses the pointer style to specify parameters, so even for basic parameters, you need to use pointers to assign values to them
     * The SDK provides encapsulation functions for importing the pointers of basic parameters
     * Help link:
     * SMS console: https://console.tencentcloud.com/smsv2
     * sms helper：https://www.tencentcloud.com/document/product/382/3773?from_cn_redirect=1
     */
﻿
    /* SMS application ID, which is the `SDKAppID` generated after an application is added in the [SMS console], such as 1400006666 */
    request.SmsSdkAppid = common.StringPtr("1400787878")
    /* Maximum number of pulled entries. Maximum value: 100 */
    request.Limit = common.Uint64Ptr(0)
    /* Offset, which is currently fixed at 0 */
    request.Offset = common.Uint64Ptr(0)
    /* Start time of pull in the format of `yyyymmddhh` accurate to the hour */
    request.StartDateTime = common.Uint64Ptr(2019122400)
    /* End time of pull in the format of `yyyymmddhh` accurate to the hour
     * Note: `EndDataTime` must be after `StartDateTime` */
    request.EndDataTime = common.Uint64Ptr(2019122523)
﻿
    // Call the API you want to access through the client object. You need to pass in the request object
    response, err := client.SendStatusStatistics(request)
    // Handle the exception
    if _, ok := err.(*errors.TencentCloudSDKError); ok {
        fmt.Printf("An API error has returned: %s", err)
        return
    }
    // This is a direct failure instead of SDK exception. You can add other troubleshooting measures in the real code
    if err != nil {
        panic(err)
    }
    b, _ := json.Marshal(response.Response)
    // Print the returned JSON string
    fmt.Printf("%s", b)
}
FAQs
Proxy settings
If there is a proxy in your environment, you need to set the system environment variable https_proxy; otherwise, it may not be called normally, and a connection timeout exception will be thrown.
Enabling  DNS  cache
Currently, the SDK for Go always requests the DNS server without using the cache of nscd. You can export the environment variable GODEBUG=netdns=cgo or specify the -tags 'netcgo' parameter when compiling go build so as to get the nscd cache.
Ignoring server certificate verification
When the SDK is used to call a public cloud service, the server certificate must be verified to identify forged servers and ensure request security. However, in some extreme cases such as testing, you may need to ignore self-signed server certificates. Below is one of the possible methods:
import "crypto/tls"
...
    client, _ := cvm.NewClient(credential, regions.Guangzhou, cpf)
    tr := &http.Transport{
        TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
    }
    client.WithHttpTransport(tr)
...
Note: 
Unless you know what you are doing and understand the risks involved, do not try to disable server certificate verification.
Failure of package import with import
For example, if the error imported and not used: "os" is reported, it means that the package os is not used in the code. Therefore, simply remove it.
Help and Support

Was this page helpful?
You can also Contact sales or Submit a Ticket for help.
Help us improve! Rate your documentation experience in 5 mins.
Feedback
tencent cloud

Short Message Service

SDK for Go

Prerequisites

Relevant Documents

Installing SDK

Installing through go get (recommended)

Installing through source code

Sample Code

Applying for SMS template

Sending SMS message

Pulling receipt status

Collecting SMS message sending data

FAQs

Help and Support
